Implement Minimal Code for TDD Green Phase

This skill focuses narrowly on the GREEN phase of a red-green-refactor TDD cycle: writing the smallest possible implementation that makes a failing test pass, before any refactoring happens. It illustrates the idea with two worked examples - a Django view evolving from a simple function-based view (product_list) through a class-based View to a generic ListView, and an Express.js endpoint evolving from inline route logic through a validation middleware to a fully layered controller/service structure. In both cases the GREEN-phase code is deliberately minimal, with the more structured versions explicitly labeled as REFACTOR steps that come afterward.

Use this skill specifically when moving from RED to GREEN in a TDD cycle - you have a failing test and need to implement just enough behavior to pass it, keeping the implementation intentionally simple rather than reaching for the "proper" architecture immediately. It also applies when you want to record shortcuts or technical debt taken during GREEN for a later REFACTOR pass.

Do not use it when you're already in the refactor phase and optimizing for design or performance, when tests are already passing and you're adding new requirements (that calls for a new RED phase first), or when what's actually needed is a full architectural redesign rather than an incremental TDD step.

Input is a failing test (or the next failing test in a suite) describing required behavior. Output is the smallest code change that makes it pass - illustrated here as a bare Django function view or an inline Express route handler - plus a note of any shortcuts taken for the refactor phase to address later.

# Django GREEN phase example (function-based view)
def product_list(request):
    products = Product.objects.all()
    return JsonResponse({'products': list(products.values())})

Worked examples cover Django (function view -> class-based View -> generic ListView) and Express.js (inline handler -> validation middleware -> layered controller/service), and the skill points to a companion resources/implementation-playbook.md for further pattern detail.

Developers actively running a TDD cycle who need a concrete reminder to keep the GREEN-phase implementation minimal and defer structural improvements (layering, generic views, middleware extraction) to the REFACTOR phase, rather than gold-plating the first passing version.