Task Master AI Development Workflow

A systematic three-phase development workflow integrating Task Master AI CLI for structured task management, code analysis, and implementation tracking within Claude Code.

Overview

This skill enforces a disciplined development approach:

1. **Analyze Problem** - Deep code exploration before action

2. **Plan Solution** - Structured planning with file change tracking

3. **Execute Solution** - Implementation with type-checking

Task Master AI provides task decomposition, complexity analysis, and progress tracking through PRD parsing and hierarchical task management.

Core Workflow Phases

Phase 1: Analyze Problem

**Declaration**: `【分析问题】`

**Purpose**: Gather sufficient context for correct decision-making when multiple approaches exist.

**Required Actions**:

**Absolutely Forbidden**:

**Phase Transition**: Ask clarifying questions. If multiple viable approaches exist and you cannot decide, present options as part of your questions. If no questions needed, proceed to Phase 2.

Phase 2: Plan Solution

**Declaration**: `【制定方案】`

**Prerequisites**: User has explicitly answered key technical decisions.

**Required Actions**:

**Auto-Execute Condition**: If ≤3 files AND ≤30 lines total, automatically proceed to Phase 3 without user confirmation.

Phase 3: Execute Solution

**Declaration**: `【执行方案】`

**Required Actions**:

**Absolutely Forbidden**:

**Exception**: If uncertain issues arise during implementation, pause and ask questions.

Task Master AI Commands

Project Initialization

```bash

task-master init # Initialize Task Master in project

task-master parse-prd .taskmaster/docs/prd.txt # Generate tasks from PRD

task-master models --setup # Configure AI models interactively

```

Daily Development Loop

```bash

task-master next # Get next available task

task-master show <id> # View task details (e.g., task-master show 1.2)

task-master set-status --id=<id> --status=done # Mark task complete

```

Task Management

```bash

task-master add-task --prompt="description" --research # Add new task with AI

task-master expand --id=<id> --research --force # Break into subtasks

task-master update-subtask --id=<id> --prompt="notes" # Log implementation notes

task-master update-task --id=<id> --prompt="changes" # Update specific task

task-master update --from=<id> --prompt="changes" # Update multiple tasks

```

Analysis & Planning

```bash

task-master analyze-complexity --research # Analyze task complexity

task-master complexity-report # View complexity report

task-master expand --all --research # Expand all eligible tasks

```

Dependencies & Organization

```bash

task-master add-dependency --id=<id> --depends-on=<id> # Add task dependency

task-master validate-dependencies # Check dependency issues

task-master move --from=<id> --to=<id> # Reorganize hierarchy

```

Task ID Format

Task Statuses

Iterative Implementation Pattern

1. `task-master show <subtask-id>` - Understand requirements

2. Explore codebase and plan approach (Phase 1: Analyze)

3. `task-master update-subtask --id=<id> --prompt="detailed plan"` - Log plan

4. `task-master set-status --id=<id> --status=in-progress` - Start work

5. Present plan to user for approval (Phase 2: Plan)

6. Implement code following approved plan (Phase 3: Execute)

7. `task-master update-subtask --id=<id> --prompt="outcomes"` - Log results

8. `task-master set-status --id=<id> --status=done` - Complete

Key Files Structure

```

project/

├── .taskmaster/

│ ├── tasks/

│ │ ├── tasks.json # Main task database

│ │ └── task-*.md # Individual task files

│ ├── docs/

│ │ └── prd.txt # Product requirements

│ ├── reports/

│ │ └── task-complexity-report.json

│ └── config.json # AI model configuration

├── CLAUDE.md # This workflow (auto-loaded)

├── .env # API keys

└── .mcp.json # MCP server config

```

MCP Integration

Configure in `.mcp.json`:

```json

{

"mcpServers": {

"task-master-ai": {

"command": "npx",

"args": ["-y", "--package=task-master-ai", "task-master-ai"],

"env": {

"ANTHROPIC_API_KEY": "your_key_here",

"PERPLEXITY_API_KEY": "your_key_here"

}

}

}

}

```

**Essential MCP Tools**:

Required API Keys

At least **one** required (Anthropic + Perplexity recommended):

Best Practices

Context Management

Complex Workflows

1. Create markdown PRD describing changes: `touch migration-plan.md`

2. Parse with `task-master parse-prd --append`

3. Analyze complexity and expand: `task-master analyze-complexity --research`

4. Work through systematically, logging progress

Git Integration

```bash

Reference tasks in commits

git commit -m "feat: implement JWT auth (task 1.2)"

Create PR for completed task

gh pr create --title "Complete task 1.2: User authentication"

```

Parallel Development

```bash

Create worktrees for parallel tasks

git worktree add ../project-auth feature/auth

git worktree add ../project-api feature/api

Run Claude Code in each

cd ../project-auth && claude

cd ../project-api && claude

```

Troubleshooting

**AI Commands Failing**:

```bash

cat .env # Check API keys

task-master models # Verify model config

task-master models --set-fallback gpt-4o-mini # Try different model

```

**Task Sync Issues**:

```bash

task-master generate # Regenerate task files

task-master fix-dependencies # Fix dependency issues

```

Important Notes

Example Session

```bash

Initialize project

task-master init

task-master parse-prd .taskmaster/docs/prd.txt

task-master analyze-complexity --research

task-master expand --all --research

Daily workflow

task-master next

【分析问题】

[Perform deep code analysis...]

[Ask clarifying questions...]

User answers questions

【制定方案】

[List files to change...]

[Get approval if >3 files or >30 lines...]

【执行方案】

task-master set-status --id=1.2 --status=in-progress

[Implement per plan...]

[Run type-checking...]

task-master update-subtask --id=1.2 --prompt="Implemented JWT auth with bcrypt hashing"

task-master set-status --id=1.2 --status=done

```