Nm Attune Project Execution

> Night Market Skill — ported from claude-night-market/attune. For the full experience with agents, hooks, and commands, install the Claude Code plugin.

Table of Contents

Project Execution Skill

Execute implementation plan systematically with checkpoints, validation, and progress tracking.

When To Use

When NOT To Use

Integration

With superpowers:

Without superpowers:

Execution Framework

Pre-Execution Phase

Actions: 1. Load implementation plan 2. Validate project initialized 3. Check dependencies installed 4. Review task dependency graph 5. Identify starting tasks (no dependencies)

Validation:

Task Execution Loop

For each task in dependency order:

1. PRE-TASK
   - Verify dependencies complete
   - Review acceptance criteria
   - Create feature branch (optional)
   - Set up task context
2. IMPLEMENT (TDD Cycle)
   - Write failing test (RED)
   - Implement minimal code (GREEN)
   - Refactor for quality (REFACTOR)
   - Repeat until all criteria met
3. VALIDATE
   - All tests passing?
   - All acceptance criteria met?
   - Code quality checks pass?
   - Documentation updated?
4. CHECKPOINT
   - Mark task complete IMMEDIATELY (do NOT batch)
   - Update execution state
   - Report progress
   - Identify blockers

Task Completion Discipline: Always call TaskUpdate(taskId: "X", status: "completed") right after finishing each task—never defer completions to end of session.

Verification: Run pytest -v to verify tests pass.

Post-Execution Phase

Actions: 1. Verify all tasks complete 2. Run full test suite 3. Check code quality metrics 4. Generate completion report 5. Prepare for deployment/release

Terminal Phase Notice

This is the final phase of the attune workflow. No auto-continuation occurs after execution completes. The workflow terminates here. Unlike brainstorming, specification, and planning phases, execution does NOT auto-invoke any subsequent phase.

Task Execution Pattern

TDD Workflow

RED Phase:

# Write test that fails
def test_user_authentication():
    user = authenticate("user@example.com", "password")
    assert user.is_authenticated
Run test → FAILS (feature not implemented)

GREEN Phase:

# Implement minimal code to pass
def authenticate(email, password):
    # Simplest implementation
    user = User.find_by_email(email)
    if user and user.check_password(password):
        user.is_authenticated = True
        return user
    return None
Run test → PASSES

REFACTOR Phase:

# Improve code quality
def authenticate(email: str, password: str) -> Optional[User]:
    """Authenticate user with email and password."""
    user = User.find_by_email(email)
    if user is None:
        return None
    if not user.check_password(password):
        return None
    user.mark_authenticated()
    return user
Run test → STILL PASSES

Checkpoint Validation

Quality Gates:

- [ ] All acceptance criteria met
[ ] All tests passing (unit + integration)
[ ] Code linted (no warnings)
[ ] Type checking passes (if applicable)
[ ] Documentation updated
[ ] No regression in other components

Automated Checks:

# Run quality gates
make lint          # Linting passes
make typecheck     # Type checking passes
make test          # All tests pass
make coverage      # Coverage threshold met

Progress Tracking

Execution State

Save to .attune/execution-state.json:

{
  "plan_file": "docs/implementation-plan.md",
  "started_at": "2026-01-02T10:00:00Z",
  "last_checkpoint": "2026-01-02T14:30:22Z",
  "current_sprint": "Sprint 1",
  "current_phase": "Phase 1",
  "tasks": {
    "TASK-001": {
      "status": "complete",
      "started_at": "2026-01-02T10:05:00Z",
      "completed_at": "2026-01-02T10:50:00Z",
      "duration_minutes": 45,
      "acceptance_criteria_met": true,
      "tests_passing": true
    },
    "TASK-002": {
      "status": "in_progress",
      "started_at": "2026-01-02T14:00:00Z",
      "progress_percent": 60,
      "blocker": null
    }
  },
  "metrics": {
    "tasks_complete": 15,
    "tasks_total": 40,
    "completion_percent": 37.5,
    "velocity_tasks_per_day": 3.2,
    "estimated_completion_date": "2026-02-15"
  },
  "blockers": []
}

Progress Reports

Daily Standup:

# Daily Standup - [Date]
Yesterday
✅ [Task] ([duration])
✅ [Task] ([duration])
Today
🔄 [Task] ([progress]%)
📋 [Task] (planned)
Blockers
[Blocker] or None
Metrics
Sprint progress: [X/Y] tasks ([%]%)
[Status message]

Sprint Report:

# Sprint [N] Progress Report
Dates: [Start] - [End]
Goal: [Sprint objective]
Completed ([X] tasks)
[Task list]
In Progress ([Y] tasks)
[Task] ([progress]%)
Blocked ([Z] tasks)
[Task]: [Blocker description]
Burndown
Day 1: [N] tasks remaining
Day 5: [M] tasks remaining ([status])
Estimated completion: [Date] ([delta])
Risks
[Risk] or None identified

Blocker Management

Blocker Detection

Common Blockers:

Systematic Debugging

When blocked, apply debugging framework:

1. Reproduce: Create minimal reproduction case 2. Hypothesize: Generate possible causes 3. Test: Validate hypotheses one by one 4. Resolve: Implement fix or workaround 5. Document: Record solution for future

Escalation

When to escalate:

Escalation format:

## Blocker: [TASK-XXX] - [Issue]
Symptom: [What's happening]
Impact: [Which tasks/timeline affected]
Attempted Solutions:
1. [Solution 1] - [Result]
2. [Solution 2] - [Result]
Recommendation: [Proposed path forward]
Decision Needed: [What needs to be decided]

Quality Assurance

Definition of Done

Task is complete when:

Testing Strategy

Test Pyramid:

Verification: Run pytest -v to verify tests pass.
     /\
    /E2E\      Few, slow, expensive
   /------\
  /  INT  \    Some, moderate speed
 /----------\
/   UNIT    \  Many, fast, cheap

Per Task:

Velocity Tracking

Burndown Metrics

Track daily:

Formulas:

Verification: Run pytest -v to verify tests pass.
Velocity = Tasks completed / Days elapsed
Estimated completion = Tasks remaining / Velocity
On track? = Estimated completion <= Sprint end date

Velocity Adjustments

If ahead of schedule:

If behind schedule:

Related Skills

Related Agents

Related Commands

Mission Report

At mission completion, produce a Mission Report using the template from references/mission-report.md. The report documents:

See references/mission-report.md for the full template and example reports for successful, partial, and failed missions.

Examples

See /attune:execute command documentation for complete examples.

Troubleshooting

Common Issues

Command not found Ensure all dependencies are installed and in PATH

Permission errors Check file permissions and run with appropriate privileges

Unexpected behavior Enable verbose logging with --verbose flag

See /attune:execute command documentation for complete examples.

Common Issues

Command not found Ensure all dependencies are installed and in PATH

Permission errors Check file permissions and run with appropriate privileges

Unexpected behavior Enable verbose logging with --verbose flag