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.

taskfile-automation