2 code_generation {{task}} {{context}} {{#each requirements}} {{this}} {{/each}} {{allowed_libraries}} {{forbidden_approaches}} {{complexity_limits}} {{integration_requirements}} REQUIRED - Write tests BEFORE implementation Use project's existing test framework (detected via /testing:prime) 100% for new code 1. Write failing test (RED) 2. Write minimal code to pass (GREEN) 3. Refactor while tests pass (REFACTOR) Test Files Comprehensive test suite written FIRST (TDD Red phase) {{test_format}} YES Implementation Code Minimal code to make tests pass (TDD Green phase) {{code_format}} YES Refactored Code Clean, maintainable code after refactoring (TDD Refactor phase) {{code_format}} YES Usage Documentation Code comments and brief usage examples Inline comments + optional README section NO Before generating code: 1. UNDERSTAND REQUIREMENTS: - What exactly needs to be implemented? - What are the edge cases? - What constraints must be followed? 2. DESIGN THE TESTS FIRST: - What are the test cases for happy path? - What are the test cases for edge cases? - What are the test cases for error conditions? - How will tests be structured? 3. PLAN THE IMPLEMENTATION: - What is the minimal code to pass tests? - What functions/classes are needed? - How will they interact? - What design patterns apply? 4. IDENTIFY INTEGRATION POINTS: - What existing code needs to be called? - What APIs/services are used? - How is error handling done? 5. CONSIDER REFACTORING: - What code smells to avoid? - What design principles to follow? - When to refactor vs. keep it simple? CRITICAL: Follow TDD strictly - Tests MUST be written first - Implementation MUST be minimal - Refactoring MUST happen while tests are green - NO skipping TDD phases {{#if existing_code}} Current code to refactor or extend {{existing_code}} {{/if}} {{#if example}} Reference implementation pattern from codebase {{example}} {{/if}} Tests written before implementation Tests fail initially (RED phase confirmed) Minimal implementation to pass tests All tests passing (GREEN phase achieved) Code refactored for clarity All tests still passing after refactor No code duplication Single responsibility principle followed Proper error handling No resource leaks Consistent naming with codebase