implementation-phase

Inputs: tasks.md (20-30 tasks), plan.md (implementation plan) Outputs: Implemented code, test suites, updated tracking files Expected duration: 2-10 days (varies by complexity)

<quick_start> Execute implementation tasks systematically:

1. Load tech stack constraints from docs/project/tech-stack.md
2. Review task dependencies in tasks.md for parallel work
3. Generate test suite using test-architect (complex features)
4. Execute tasks using TDD (RED → GREEN → REFACTOR)
5. Update task status in NOTES.md after completion
6. Run anti-duplication checks before writing new code
7. Run tests + type-check after each task triplet
8. Validate type safety with type-enforcer (TypeScript)
9. Validate security with security-sentry (auth/API/uploads)
10. Commit implementation with descriptive messages

Key principle: Test first, implement second. Never write code without tests. </quick_start>

Validate environment with test run before proceeding.

Before writing any code, load technology constraints from docs/project/tech-stack.md:

# Read tech stack documentation
cat docs/project/tech-stack.md

# Extract: database, framework, libraries, deployment platform

Prevents hallucinating wrong technologies (e.g., suggesting MongoDB when PostgreSQL required).

See resources/tech-stack-validation.md for validation checklist.

Analyze tasks.md for dependency relationships:

# Look for dependencies in tasks.md

T001: Create User model [no dependencies]
T002: Create AuthService [depends: T001]
T003: Create LoginController [depends: T002]

Identify parallel work opportunities:

• Independent tasks can run concurrently
• Dependent tasks must run sequentially

See resources/task-batching.md for parallel execution strategy.

For complex features (>10 tasks, multiple components), use test-architect agent:

# Launch test-architect to convert acceptance criteria → tests
# Agent reads tasks.md acceptance criteria
# Generates comprehensive test suite (unit + integration + E2E)

Benefits:

• Tests written before implementation (pure TDD)
• Coverage of happy paths, edge cases, error conditions
• Executable specification from acceptance criteria

See resources/tdd-workflow.md#test-architect for detailed usage.

For each task, follow RED → GREEN → REFACTOR cycle:

RED (Write Failing Test):

def test_user_can_login_with_valid_credentials():
    """Test user authentication with correct email/password"""
    user = create_user(email="[email protected]", password="secure123")
    result = auth_service.login("[email protected]", "secure123")

    assert result.success is True
    assert result.user.email == "[email protected]"
    assert result.token is not None

GREEN (Minimal Implementation):

def login(email, password):
    user = User.query.filter_by(email=email).first()
    if user and user.check_password(password):
        token = generate_jwt(user.id)
        return LoginResult(success=True, user=user, token=token)
    return LoginResult(success=False)

REFACTOR (Clean Up):

• Extract magic values to constants
• Remove duplication
• Improve naming
• Add error handling

See resources/tdd-workflow.md for complete RED → GREEN → REFACTOR guide.