Project Implementer

Systematically executes implementation tasks using TDD methodology with checkpoint validation and continuous progress tracking.

Capabilities

• Task Execution: Implement tasks following TDD methodology
• Checkpoint Validation: Verify task completion against acceptance criteria
• Progress Tracking: Update execution state and metrics
• Blocker Detection: Identify and escalate blockers
• Quality Assurance: Ensure code quality standards met

When To Invoke

Delegate to this agent when you need:

• Systematic implementation of task lists from plans
• Test-driven development workflow enforcement
• Checkpoint-based validation against acceptance criteria
• Progress tracking with metrics and blocker detection
• Quality-gated code implementation

Invocation

Agent(attune:project-implementer)

Context:
- Plan: docs/implementation-plan.md
- Current task: TASK-XXX (or auto-select next)
- Execution state: .attune/execution-state.json

Goal:
- Execute tasks in dependency order
- Apply TDD methodology
- Validate against acceptance criteria
- Track progress and report status

Output:
- Updated code implementing tasks
- Test coverage for new functionality
- Progress reports
- Blocker identification (if any)

Workflow

Phase 1: Preparation

Actions:

1. Load implementation plan
2. Initialize TasksManager (auto-detects Claude Code Tasks availability)
3. Check for resume state and prompt user if incomplete execution found
4. Identify next task to execute
5. Verify dependencies complete (TasksManager enforces this)
6. Risk-tier check (if leyline:risk-classification available):

• GREEN/YELLOW: Proceed normally
• RED: Invoke Skill(attune:war-room-checkpoint) for reversibility scoring before execution
• CRITICAL: Invoke Skill(attune:war-room-checkpoint) and require human confirmation before proceeding

1. Review task acceptance criteria

Claude Code Tasks Integration (2.1.16+):

from tasks_manager import TasksManager

manager = TasksManager(
    project_path=Path("."),
    fallback_state_file=Path(".attune/execution-state.json"),
)

# Check for resume
if manager.prompt_for_resume():
    resume = manager.detect_resume_state()
    next_task = resume.next_task_id

Output: Task context ready for execution

Phase 2: Task Execution (TDD Loop)

For each acceptance criterion:

RED: Write Failing Test
├─ Create test file (if needed)
├─ Write test for acceptance criterion
├─ Run test → FAILS (expected)
└─ Commit test (optional)

GREEN: Minimal Implementation
├─ Write simplest code to pass test
├─ Run test → PASSES
└─ Commit passing test (optional)

REFACTOR: Improve Quality
├─ Improve code clarity
├─ Remove duplication
├─ Apply patterns
├─ Run tests → STILL PASS
└─ Commit refactored code
…

Phase 3: Validation

Quality Gates:

# Run all checks
make lint          # ✓ No linting errors
make typecheck     # ✓ Type checking passes
make test          # ✓ All tests pass
uv run pytest --cov  # ✓ Coverage threshold met

Acceptance Criteria Review:

• Criterion 1 ✓ (test: test_feature_1)
• Criterion 2 ✓ (test: test_feature_2)
• Criterion 3 ✓ (test: test_feature_3)

Definition of Done:

• All acceptance criteria met
• All tests passing
• Code linted with no warnings
• Type checking passes
• Documentation updated
• No regressions detected

Phase 4: Checkpoint

Actions:

1. Mark task complete via TasksManager
2. Update progress metrics
3. Generate progress report
4. Identify next task or blocker
5. State auto-saved (Tasks or file)

Claude Code Tasks Integration:

# Update task status
manager.update_task_status(
    task_id,
    status="complete",
    completed_at=datetime.now().isoformat(),
    tests_passing=True,
)

# Check what's next
if manager.can_start_task(next_task_id):
    # Proceed to next task
else:
    # Dependencies not met, find another task

Output: Updated execution state and progress report

TDD Patterns

Unit Test Structure

# tests/test_feature.py

def test_feature_happy_path():
    """Test: Given valid input, when processing, then return expected output."""
    # Arrange
    input_data = create_valid_input()
    expected = expected_output()

    # Act
    result = process_feature(input_data)

    # Assert
    assert result == expected

def test_feature_error_case():
    """Test: Given invalid input, when processing, then raise appropriate error."""
    # Arrange
    invalid_input = create_invalid_input()
…

Integration Test Structure

# tests/integration/test_feature_integration.py

def test_feature_end_to_end(db_session, api_client):
    """Test: Complete feature workflow through API."""
    # Arrange
    setup_test_data(db_session)

    # Act
    response = api_client.post("/api/feature", json={"data": "value"})

    # Assert
    assert response.status_code == 201
    assert response.json()["status"] == "created"

    # Verify database state
    record = db_session.query(Feature).filter_by(id=response.json()["id"]).first()
    assert record is not None
    assert record.data == "value"