Task Automation System

Use this skill when working with projects that use Task to provide easy-to-discover automation commands for development workflows.

Core Principle

IMPORTANT: Always prefer task commands over direct shell/language commands when a Taskfile is present.

Task provides:

• Discoverability: task --list shows all available tasks

• Consistency: Standardised commands across different environments

• Documentation: Built-in descriptions and help

• Automation: Multi-step workflows (e.g., task dev combines testing and docs)

• Safety: Interactive prompts for destructive operations

Task Discovery

Find Available Tasks

# List all available tasks with descriptions

task --list

# Show common workflows and usage patterns

task help

# Get detailed help for specific task

task <taskname> --help

Always start with discovery when entering a new project with a Taskfile.

Common Task Patterns

Development Workflows

Projects typically provide these standard tasks:

# Fast development cycle (common iteration loop)

task dev          # Usually runs fast tests + fast docs

# Pre-commit workflow

task precommit    # Runs pre-commit hooks + fast tests

# Full CI simulation locally

task ci           # Complete CI pipeline locally

Testing Workflows

# Full test suite including quality checks

task test

# Fast tests (skip quality checks for rapid development)

task test-fast

task test:fast    # Alternative naming

# Quality checks only (Aqua, formatting, linting)

task test-quality

task test:quality

Documentation Building

# Quick docs build (recommended for development)

task docs-fast

task docs:fast

# Full documentation including slow components (notebooks, etc.)

task docs

# Interactive documentation server

task docs-pluto   # For Julia projects with Pluto notebooks

task docs:serve   # For live-reload documentation server

Environment Management

# Set up development environment from scratch

task setup

# Show package/dependency status

task pkg:status

task status

# Project overview and environment information

task info

Code Quality

# Linting

task lint

# Formatting

task format

# Combined quality checks

task quality

Using Task vs Direct Commands

When to Use Task

Use task commands when:

• A Taskfile exists in the project

• You need to run standard development operations

• You want to discover available workflows

• You need consistency across team members

When Task Wraps Underlying Commands

Tasks are typically thin wrappers around language-specific commands:

Example - Julia:

# Task command

task test

# Underlying command it runs

julia --project=. -e 'using Pkg; Pkg.test()'

Example - R:

# Task command

task docs

# Underlying command it runs

Rscript -e "devtools::document()"

When to Use Direct Commands

Use direct language commands when:

• No Taskfile exists

• You need advanced options not exposed by tasks

• You're doing exploratory work outside standard workflows

• Tasks don't cover your specific use case

Task Workflow Examples

Typical Development Cycle

# 1. Discover what's available

task --list

# 2. Run fast iteration cycle

task dev          # Fast tests + fast docs

# 3. Before committing

task precommit    # Pre-commit checks + tests

# 4. Before pushing (optional)

task ci           # Full CI simulation

First-Time Setup

# 1. See what setup tasks exist

task --list | grep setup

# 2. Run setup

task setup        # Install dependencies, configure environment

# 3. Verify setup

task info         # Show project and environment status

# 4. Test everything works

task test

Task Naming Conventions

Common patterns in task names:

Prefixes:

• test:* - Testing-related tasks

• docs:* - Documentation tasks

• pkg:* - Package management tasks

• ci:* - CI/CD related tasks

Suffixes:

• *-fast - Quick version of the task

• *-full - Complete version including optional steps

Special names:

• dev - Fast development iteration cycle

• precommit - Pre-commit validation

• ci - Full CI pipeline

• setup - Initial project setup

• clean - Clean build artifacts

• help - Show usage information

Integration with Language Tools

Julia Projects

# Instead of: julia --project=. -e 'using Pkg; Pkg.test()'

task test

# Instead of: julia --project=docs docs/make.jl --skip-notebooks

task docs-fast

# Instead of: julia --project=. -e 'using Pkg; Pkg.update()'

task pkg:update

R Projects

# Instead of: Rscript -e "devtools::test()"

task test

# Instead of: Rscript -e "devtools::document()"

task docs

# Instead of: Rscript -e "devtools::check()"

task check

Python Projects

# Instead of: pytest

task test

# Instead of: sphinx-build docs docs/_build

task docs

# Instead of: pip install -e .

task install

Task Configuration Files

Taskfile Location

Look for:

• Taskfile.yml in project root

• Taskfile.yaml in project root

Understanding Task Definitions

When reading a Taskfile:

• cmds: - Commands executed by the task

• deps: - Dependencies run before this task

• desc: - Description shown in task --list

• summary: - Extended description for task <name> --help

Best Practices

• Always discover first: Run task --list when entering a project

• Use task help: Check task help for project-specific guidance

• Prefer tasks for standard workflows: Use tasks for dev, test, docs

• Direct commands for exploration: Use language commands for ad-hoc work

• Check task definitions: Look at Taskfile.yml to understand what tasks do

• Update documentation: If tasks change workflows, note it

When to Use This Skill

Activate this skill when:

• Working with projects that have a Taskfile.yml/Taskfile.yaml

• You see mentions of "Task" or "task commands" in project documentation

• Project CLAUDE.md mentions using task instead of direct commands

• You need to discover available development workflows

• Running tests, building docs, or managing project development tasks

This skill helps you leverage Task automation rather than manually running underlying commands.

Project-specific task definitions and workflows remain in project documentation.