taskfile-automation

SKILL.md

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.