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 --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.