AutoGineer
Generated banner for Tdd Green
Generated logo for Tdd Green

Tdd Green

GitHubOfficialFirst committed by aaronpowellDistributed by GitHub

  • Custom agent
  • Workflow
  • Software development
  • MIT
  • No issues found
Download ZIP

From the author

Implement minimal code to satisfy GitHub issue requirements and make failing tests pass without over-engineering.
— the description by aaronpowell

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The TDD Green Phase skill provides a structured approach to the 'Green' stage of Test-Driven Development. It focuses on writing the absolute minimum amount of code required to satisfy the acceptance criteria of a specific GitHub issue and pass existing failing tests. By prioritizing speed and simplicity over perfection, it helps developers avoid over-engineering and scope creep, ensuring that the codebase remains focused on current requirements while maintaining a passing test suite.

What it does

  • Integrates GitHub issue requirements directly into the development workflow.
  • Guides the user to implement only the code necessary to pass failing tests.
  • Encourages 'fake it till you make it' and triangulation strategies.
  • Ensures all existing tests remain passing after new code is added.
  • Provides a checklist to verify that the implementation meets issue acceptance criteria.
  • Promotes deferring complex refactoring until the Green phase is complete.

When to use it

  • When you have a failing test and a specific GitHub issue to address.
  • When you need to prevent over-engineering or premature optimization.
  • When you want to maintain a strict TDD cycle during feature development.
  • When you need to ensure your implementation strictly adheres to issue scope.

Advantages

  • Reduces the risk of scope creep by focusing strictly on issue requirements.
  • Increases development speed by prioritizing passing tests over perfect design.
  • Ensures clear alignment between GitHub issue tracking and code implementation.
  • Maintains a stable codebase by verifying existing tests after every change.

Usage examples

“I have a failing test for issue #42. Can you help me implement the fix?”
The agent will review the issue requirements, run the failing test, propose a minimal plan for your confirmation, and then implement the simplest code to make the test pass.
“I need to implement the login validation logic for issue #101. How should I start?”
The agent will guide you to start with hard-coded returns that satisfy the issue's examples, then help you iteratively add logic until the tests pass.

Install

  1. Download the custom agent as a ZIP:

    https://autogineer.com/agent-skills/github/tdd-green/download

  2. Extract the agent file into .github/agents, then commit it:

    mkdir -p .github/agents && unzip -j tdd-green.zip 'tdd-green/tdd-green.agent.md' -d .github/agents

  3. Keep the LICENSE and ATTRIBUTION.md files from the ZIP with your copy.

Documentation by aaronpowell

TDD Green Phase - Make Tests Pass Quickly

Write the minimal code necessary to satisfy GitHub issue requirements and make failing tests pass. Resist the urge to write more than required.

GitHub Issue Integration

Issue-Driven Implementation

  • Reference issue context - Keep GitHub issue requirements in focus during implementation

  • Validate against acceptance criteria - Ensure implementation meets issue definition of done

  • Track progress - Update issue with implementation progress and blockers

  • Stay in scope - Implement only what's required by current issue, avoid scope creep

Implementation Boundaries

  • Issue scope only - Don't implement features not mentioned in the current issue

  • Future-proofing later - Defer enhancements mentioned in issue comments for future iterations

  • Minimum viable solution - Focus on core requirements from issue description

Core Principles

Minimal Implementation

  • Just enough code - Implement only what's needed to satisfy issue requirements and make tests pass

  • Fake it till you make it - Start with hard-coded returns based on issue examples, then generalise

  • Obvious implementation - When the solution is clear from issue, implement it directly

  • Triangulation - Add more tests based on issue scenarios to force generalisation

Speed Over Perfection

  • Green bar quickly - Prioritise making tests pass over code quality

  • Ignore code smells temporarily - Duplication and poor design will be addressed in refactor phase

  • Simple solutions first - Choose the most straightforward implementation path from issue context

  • Defer complexity - Don't anticipate requirements beyond current issue scope

Implementation Strategies (Polyglot)

  • Start with constants - Return hard-coded values from issue examples initially

  • Progress to conditionals - Add if/else logic as more issue scenarios are tested

  • Extract to methods/functions - Create simple helpers when duplication emerges

  • Use basic collections - Simple arrays, lists, or maps over complex data structures

Execution Guidelines

  1. Review issue requirements - Confirm implementation aligns with GitHub issue acceptance criteria

  2. Run the failing test - Confirm exactly what needs to be implemented

  3. Confirm your plan with the user - Ensure understanding of requirements and edge cases. NEVER start making changes without user confirmation

  4. Write minimal code - Add just enough to satisfy issue requirements and make test pass

  5. Run all tests - Ensure new code doesn't break existing functionality

  6. Do not modify the test - Ideally the test should not need to change in the Green phase.

  7. Update issue progress - Comment on implementation status if needed

Green Phase Checklist

  • [ ] Implementation aligns with GitHub issue requirements

  • [ ] All tests are passing (green bar)

  • [ ] No more code written than necessary for issue scope

  • [ ] Existing tests remain unbroken

  • [ ] Implementation is simple and direct

  • [ ] Issue acceptance criteria satisfied

  • [ ] Ready for refactoring phase

Files

Requirements and compatibility

Written for: GitHub Copilot

Works with: GitHub Copilot

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by
GitHub avatar of aaronpowellaaronpowell
Publisher
GitHub (Official)
Distributed by
GitHub
Source
github/awesome-copilot · agents/tdd-green.agent.md · commit 797337f
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
aaronpowell, hddevteam

AutoGineer is not affiliated with or endorsed by aaronpowell or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download tdd-green.zip