/execute

name: execute
description: "Execute implementation plan systematically with progress tracking and checkpoint validation"

Attune Execute Command

Execute implementation plans systematically with task tracking, checkpoint validation, and continuous progress reporting.

When To Use

Use this command when you need to:

• Execute implementation plan with task tracking
• Implement tasks in dependency order
• Validate checkpoints against acceptance criteria
• Track progress and identify blockers
• Monitor velocity and burndown metrics
• Ensure systematic quality-gated execution

When NOT To Use

Avoid this command if:

• No implementation plan exists (use `/attune:blueprint` first)
• Still planning or designing (complete planning phase)
• Single isolated task (execute directly without framework)
• Exploratory coding or quick prototype (too much overhead)

Usage

# Start execution from plan
/attune:execute

# Execute specific task
/attune:execute --task T003

# Resume from checkpoint
/attune:execute --resume

# Execute specific phase
/attune:execute --phase "Phase 1"

What This Command Does

1. **Loads implementation plan** from planning phase 2. **Invokes execution agent** with superpowers integration 3. **Executes tasks** in dependency order with checkpoints 4. **Tracks progress** and updates task status 5. **Validates completion** against acceptance criteria 6. **Reports progress** with metrics and blockers

Integration with Superpowers

When superpowers plugin is available:

• Uses `Skill(superpowers:executing-plans)` for systematic execution
• Uses `Skill(superpowers:systematic-debugging)` for issue resolution
• Uses `Skill(superpowers:verification-before-completion)` for validation

Without superpowers:

• Falls back to attune's native execution agent
• Provides similar checkpoint-based approach
• Validates task completion systematically

Workflow

# 1. Load implementation plan
# Read docs/implementation-plan.md

# 2. Invoke execution agent
Agent(attune:project-implementer)

# 3. Execute tasks in dependency order:
#    For each task:
#      - Check dependencies complete
#      - Execute implementation
#      - Run tests
#      - Validate acceptance criteria
#      - Update progress tracker

# 4. Report progress
#    - Tasks completed/total
#    - Blockers and risks
#    - Next actions

# 5. Save execution state
#    - .attune/execution-state.json

Execution Phases

Phase 1: Preparation

**Actions**:

• Load implementation plan
• Validate project initialized (run /attune:project-init if needed)
• Check dependencies installed
• Review task dependency graph

**Output**: Execution plan with ordered task list

Phase 2: Task Execution Loop

**For each task in order**:

1. **Pre-execution**:
   - Verify dependencies complete
   - Review acceptance criteria
   - Create feature branch (if needed)

2. **Implementation**:
   - Write code following spec
   - Run tests continuously (TDD)
   - Document as you go

3. **Validation**:
   - All acceptance criteria met?
   - Tests passing?
   - Code review ready?

4. **Checkpoint**:
   - Mark task complete
   - Update progress tracker
   - Identify blockers

Phase 3: Progress Reporting

**Metrics Tracked**:

• Tasks completed vs. total
• Tasks in progress
• Blocked tasks
• Estimated completion percentage
• Velocity (tasks/day)

**Reports Generated**:

• Daily standup summary
• Sprint progress report
• Blocker identification
• Risk assessment updates

Arguments

• `--task <task-id>` - Execute specific task (e.g., T003)
• `--phase <phase-name>` - Execute specific phase
• `--resume` - Resume from last checkpoint
• `--dry-run` - Preview execution without applying changes
• `--parallel` - Execute nonconflicting tasks in parallel (DEFAULT for independent tasks)

Examples

Example 1: Full Execution

/attune:blueprint
/attune:project-init --lang python
/attune:execute

**Session Output**:

🚀 Executing Implementation Plan

Plan: docs/implementation-plan.md
Total tasks: 40
Current sprint: Sprint 1 (Foundation)

─────────────────────────────────────
Phase 1: Foundation (10 tasks)
─────────────────────────────────────

[✓] T001: Initialize Project Structure
    ├─ Created project with /attune:project-init
    ├─ All tests passing
    └─ Duration: 45 minutes

[▶] T002: Database Schema Design
    ├─ Creating migration: migrations/001_initial.sql
    ├─ Running: alembic revision --autogenerate
    └─ Progress: 60%

Checkpoint: 1/10 tasks complete (10%)
Next: Complete T002, start T003
Blockers: None

Example 2: Execute Specific Task

/attune:execute --task T005

**Detailed Task Execution**:

📋 Executing T005: Implement OAuth Flow

Dependencies: T004 (Complete ✓)

Acceptance Criteria:
- [ ] GitHub OAuth app configured
- [ ] Login redirect to GitHub
- [ ] Callback handles tokens
- [ ] User session created
- [ ] Tests cover happy + error paths

Step 1/5: Configure GitHub OAuth App
→ Creating OAuth app in GitHub Settings...
→ Setting callback URL: http://localhost:8000/auth/callback
→ Storing client_id and client_secret in .env
✓ Complete

Step 2/5: Implement login endpoint
→ Creating backend/app/auth/oauth.py...
→ Writing tests/auth/test_oauth.py...
[Code implementation details...]
✓ Complete (tests passing)

Step 3/5: Implement callback handler
[... implementation ...]

Progress: 3/5 steps (60%)
Estimated completion: 30 minutes

Example 3: Resume from Checkpoint

/attune:execute --resume

Loads state from `.attune/execution-state.json`:

🔄 Resuming Execution

Last checkpoint: 2026-01-02 14:30:22
Completed: 15/40 tasks (37.5%)
Last task: T015 (Complete)
Next task: T016

Resuming with T016...

Example 4: Phase-Specific Execution

/attune:execute --phase "Phase 2"

Executes only Phase 2 tasks (T011 through T030).

Claude Code Tasks Integration (2.1.16+)

When running in Claude Code 2.1.16+, execution uses th