---

name: auto-dev-workflow description: Unified task-driven development workflow combining automated planning, fine-grained execution, and deployment. Supports flat or hierarchical tasks, long-running tasks with shell verification, and multiple deployment modes. Trigger with /auto-dev-workflow. tools: Read, Write, Edit, Glob, Bash, TaskCreate, TaskUpdate, TaskList customModes: auto-dev-mode

Auto Dev Workflow

A standardized, task-driven development workflow that breaks projects into small, verifiable tasks and automates the implementation loop. This skill creates and manages the complete infrastructure for AI-assisted development.

Quick Start

To initialize this workflow in any project:

/auto-dev-workflow init

This creates:

• CLAUDE.md - Agent workflow instructions
• task.json - Task management file
• progress.txt - Progress tracking log
• init.sh - Environment initialization script

Core Philosophy

1. Task Decomposition: Break projects into small, testable tasks
2. Structured Loop: Initialize → Select → Implement → Test → Update → Commit
3. Human Control: AI executes, humans guide and verify
4. Progress Tracking: Complete audit trail of all work

Workflow Steps

┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ 1. Initialize│ → │ 2. Select   │ → │ 3. Implement│
│  ./init.sh   │    │   Task      │    │   Task      │
└─────────────┘    └─────────────┘    └──────┬──────┘
                                             ↓
┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ 6. Commit   │ ← │ 5. Update   │ ← │ 4. Test     │
│   Changes   │    │  Progress   │    │   & Verify  │
└─────────────┘    └─────────────┘    └─────────────┘

Files Created

CLAUDE.md

Mandatory workflow instructions for all agent sessions. Must be followed for every task.

Key sections:

• Environment initialization requirements
• Task selection criteria
• Implementation guidelines
• Testing requirements
• Progress update format

task.json

JSON file containing all project tasks with the following structure:

{
  "tasks": [
    {
      "id": 1,
      "title": "Setup project structure",
      "description": "Initialize Next.js project with TypeScript",
      "steps": [
        "Run npx create-next-app@latest",
        "Configure Tailwind CSS",
        "Setup ESLint and Prettier"
      ],
      "passes": false,
      "dependencies": [],
      "priority": "high"
    }
  ]
}

progress.txt

Human-readable work log tracking:

• Date and task completed
• Changes made
• Issues encountered
• Decisions made

init.sh

Environment initialization script that:

• Installs dependencies
• Starts development server
• Validates environment setup

Usage Patterns

Pattern 1: Starting a New Project

1. Initialize workflow:

   /auto-dev-workflow init
   

2. Define tasks:

   /auto-dev-workflow plan
   

   Describe your project, and the skill will generate task.json with appropriate tasks.

3. Start development loop:

   /auto-dev-workflow run
   

Pattern 2: Working on Existing Project

1. Analyze codebase:

   /auto-dev-workflow analyze
   

2. Generate tasks from analysis:

   /auto-dev-workflow generate-tasks "Add user authentication"
   

3. Execute single task:

   /auto-dev-workflow task 5
   

Pattern 3: Continuous Development

Run the automated development loop:

/auto-dev-workflow loop --max-runs 10

This will:

1. Read task.json
2. Find next incomplete task
3. Implement it
4. Test and verify
5. Update progress
6. Commit changes
7. Repeat until all tasks done or max-runs reached

Pattern 4: Long-Running Tasks with Shell Verification (Auto-Detected)

Note: Standard tasks now auto-detect verification type. Use long-task only for explicitly complex operations.

For tasks requiring manual step-by-step confirmation:

/auto-dev-workflow long-task "Configure Nginx with SSL and reverse proxy"

Auto-Detection Logic (applies to all tasks):

| Task Keywords | Auto-Selected Verification | |---------------|---------------------------| | install, setup, configure | Shell commands (ls, cat, systemctl) | | deploy, server, service | Shell + network verification | | docker, nginx, database | Shell verification | | create, add, fix (code) | lint/build/test | | component, page, UI | lint/build + browser testing | | file, config, document | File existence + content check |

Always applies:

• Show actual command output
• Verify before marking complete
• Report failures immediately

Task Management

Flat Structure (Default)

Simple array of tasks in task.json:

{
  "tasks": [
    {
      "id": 1,
      "title": "Setup project",
      "passes": false,
      "priority": "high"
    }
  ]
}

Hierarchical Structure (Optional)

For large projects, use Epics → Features → Tasks:

{
  "epics": [
    {
      "id": "E1",
      "title": "User Authentication",
      "features": [
        {
          "id": "F1",
          "title": "Login System",
          "tasks": [
            {
              "id": "T1",
              "title": "Create login form",
              "status": "pending",
              "priority": "high"
            }
          ]
        }
      ]
    }
  ]
}

Deployment Modes

When initializing, choose deployment mode:

| Mode | Description | Use Case | |------|-------------|----------| | local | Traditional local development | Quick prototyping | | managed | GitHub Actions + Cloud services | Production deployments | | hybrid | Local dev + Cloud deployment | Most projects |

Session State Tracking

session-state.json provides complete audit trail:

{
  "current_session": {
    "start_time": "2026-02-19T10:00:00Z",
    "mode": "long-task",
    "current_step": 3,
    "compaction_count": 1
  },
  "step_history": [
    {
      "step": 1,
      "title": "Install Docker",
      "status": "completed",
      "verification": "docker --version: 24.0.7"
    }
  ]
}

1. Read task.json
2. Find next incomplete task
3. Implement it
4. Test and verify
5. Update progress
6. Commit changes
7. Repeat until all tasks done or max-runs reached

Task Selection Criteria

When selecting the next task, prioritize:

1. Completion status: Choose tasks where passes: false
2. Dependencies: Ensure all dependency tasks are complete
3. Priority: High → Medium → Low
4. Logical order: Foundation before features

Testing Requirements

For UI Changes (Mandatory Browser Testing)

Use Playwright MCP for verification:

// Example test flow
1. Navigate to page
2. Take screenshot for visual verification
3. Test form submissions
4. Verify interactive elements

For Code Changes

Always verify:

• [ ] npm run lint passes (no errors)
• [ ] npm run build succeeds
• [ ] npm run test passes (if tests exist)
• [ ] No TypeScript errors

Progress Update Format

After each task, append to progress.txt:

## [YYYY-MM-DD HH:MM] - Task: [Task Title]

### What was done:
- Specific change 1
- Specific change 2

### Files modified:
- `src/components/Button.tsx`
- `src/lib/utils.ts`

### Tests performed:
- [x] lint passes
- [x] build succeeds
- [x] browser testing complete

### Issues encountered:
- None / Description of issues and resolutions

### Decisions made:
- Used X approach because Y

Git Commit Strategy

Each completed task should be committed separately:

git add -A
git commit -m "$(cat <<'EOF'
Task [ID]: [Task Title]

- Change 1
- Change 2

Tests: All passing
EOF
)"

Advanced Features

Task Dependencies

Define task dependencies in task.json:

{
  "id": 3,
  "title": "Add authentication",
  "dependencies": [1, 2],
  "passes": false
}

Tasks with unmet dependencies are skipped.

Priority Levels

• critical: Blocks other work
• high: Core functionality
• medium: Important features
• low: Nice to have

Task Categories

Organize tasks by category:

{
  "id": 5,
  "title": "Setup database",
  "category": "infrastructure"
}

Common categories:

• infrastructure: Setup, config, dependencies
• feature: User-facing functionality
• ui: Interface components
• api: Backend endpoints
• test: Testing infrastructure
• docs: Documentation

Best Practices

Task Size Guidelines

Good task (can be completed in 10-30 minutes):

• "Create LoginForm component with email/password fields"
• "Add /api/auth/login endpoint"

Task too large (break it down):

• "Implement authentication system" → Split into:
  • "Create auth database schema"
  • "Add login API endpoint"
  • "Create login form UI"
  • "Add session management"

Testing Strategy

1. Every task must be testable
2. Define test criteria in task description
3. Use browser testing for UI changes
4. Use unit tests for logic changes

Human Review Points

Require human confirmation for:

• Architecture decisions
• Third-party API integrations
• Security-related changes
• Database schema changes
• Deployment configurations

Customization

Adding Project-Specific Rules

Edit CLAUDE.md to add:

## Project-Specific Rules

### Naming Conventions
- Components: PascalCase
- Utilities: camelCase
- Constants: UPPER_SNAKE_CASE

### Code Style
- Use async/await over promises
- Prefer explicit types over inferred
- Always handle errors explicitly

Custom Init Script

Modify init.sh for your stack:

#!/bin/bash
# For Python projects
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# For Go projects
go mod download
go build ./...

# For Rust projects
cargo build
cargo test

Troubleshooting

Task appears stuck

1. Check progress.txt for context
2. Verify dependencies are complete
3. Consider breaking task into smaller pieces

Build/test failures

1. Run init.sh to ensure environment is correct
2. Check for missing dependencies
3. Review recent changes in progress.txt

Merge conflicts

1. Pause automation
2. Resolve conflicts manually
3. Update task.json if needed
4. Resume with /auto-dev-workflow continue

Example Projects

This workflow has been successfully used for:

• Next.js applications: Full-stack web apps with authentication
• API services: RESTful and GraphQL backends
• CLI tools: Command-line utilities
• Library packages: Reusable npm/crate/pip packages

Integration with Other Tools

MCP Servers

Recommended MCP servers for this workflow:

• Playwright: Browser testing for UI tasks
• GitHub: PR creation and issue tracking
• Supabase/Database: Data persistence tasks

Hooks

Add to .claude/settings.json:

{
  "hooks": {
    "postEdit": [
      "npm run lint --fix"
    ]
  }
}

Subagents

Use specialized subagents for:

• Security review (auth-related tasks)
• Performance analysis (optimization tasks)
• Code review (before commits)

Limitations

1. Not for greenfield architecture: Define project structure first
2. Requires clear task definitions: Ambiguous tasks lead to poor results
3. Human oversight required: Always review AI decisions
4. Best for iterative development: Not ideal for research/exploration

Further Reading

• Original inspiration: SamuelQZQ/auto-coding-agent-demo
• Claude Code documentation: /help
• Task management: TaskCreate, TaskUpdate, TaskList tools