What Is Red Green Refactor

Red-green-refactor is a test-driven development loop that helps you implement code safely. It is especially useful when you are working with AI agents, because it gives the agent a concrete feedback loop while it builds.

Instead of asking the agent to implement a whole plan and only checking the result at the end, red-green-refactor asks it to prove each step with a test.

The red-green-refactor loop

The loop has three phases:

Red: write a failing test first, then run it and confirm that it fails
Green: write the minimum implementation needed to make the test pass
Refactor: clean up the implementation while keeping the test suite green

This comes from test-driven development, often associated with Kent Beck and Extreme Programming. The important idea is that tests are not just a safety net after implementation. They drive the implementation.

Why the failing test matters

Writing the failing test first is the crucial part.

When you run a test and see it fail, you prove that the test is connected to real behavior. This is valuable when fixing bugs, because the failing test proves the bug exists before you fix it.

It is also valuable when building features, because the test gives the agent a target. The agent can run the code, inspect the failure, add logs if needed, and use the test output as feedback while it implements.

A failing test first also pushes the implementation toward testable code. Testable code is usually easier to change later, because the tests catch regressions when you move things around.

Why this matters for AI coding

AI agents tend to dive straight into implementation unless you steer them differently. That can work for small tasks, but it becomes risky when the task is larger or when code quality matters.

Red-green-refactor gives the agent a tighter loop:

write a test
run the test