Tests First Make Coding Agents More Honest

Tests first gives the agent a concrete target

When a coding agent starts with implementation, it has to invent behavior while it writes. The tests it produces later often describe whatever the code happens to do, which is the least useful kind of test. Reversing the order changes the agent's relationship to the work. Written first, a test is a statement of intent that the agent must satisfy, and that constraint narrows the search space in a helpful way. The agent cannot quietly relax a requirement if a failing assertion stands in front of it. In side-by-side runs on the same task, the tests-first run usually spends more time in planning and discussion, and less in rewriting. The code-first run feels faster at the start and then spends the saved time in repair. This is a craft observation rather than a law, and the advantage depends on how well the tests are written. A sloppy suite written first simply gives the agent a sloppier target. The order matters only when the first artifact is treated with the seriousness normally reserved for production code.

Fair comparison needs criteria agreed before the run

Comparing the two approaches fairly means agreeing on the criteria before the run, not after the result is visible. Two sessions that share a prompt, a repository state, and a model can still produce wildly different suites, so the comparison has to be about the tests themselves. Four criteria come up repeatedly in careful evaluations.

• Determinism. A good test fails for one reason and passes for one reason, so the agent's next move is unambiguous.
• Specificity. Each example names an input, an expected behavior, and the boundary it is meant to hold.
• Scope discipline. The suite covers the promised behavior and stops there, instead of wandering into unrelated internals.
• Readability. A reviewer can judge the examples without running them, which keeps the human inside the decision loop.

When a suite meets all four, the tests act as a specification the agent can execute against. When it meets none of them, the order of the work changes nothing at all. Reviewing the suite before the implementation is the cheapest way to enforce the criteria, and it prevents the agent from writing tests that flatter the code it already produced.

Ambiguity surfaces as examples instead of buried choices

Ambiguity is where the two approaches separate most sharply. Given an unclear requirement, an agent writing code first resolves the ambiguity silently and moves on, because nothing forces the decision into the open. The choice becomes an implementation detail buried in a diff, and a reviewer has to infer it. An agent that writes tests first must express the ambiguity as at least one example, and examples make the hidden choice visible. Often the agent will present two plausible behaviors and ask which behavior to encode, and that question is more valuable than any amount of clean code produced without it. The comparison is most revealing on tasks that hinge on edge cases: empty input, partial failure, ordering, retries, and timeouts. In a code-first run these tend to appear after the first draft, when changing the shape of the solution is expensive. In a tests-first run they appear before the shape exists, when the change is free. The measurable difference shows up in review comments, where reviewers argue about behavior instead of style.

Early failures teach the agent better than late ones

Failures from a test written first are a debugging signal, while failures discovered later are an accounting of mistakes. The first kind tells the agent where the behavior it promised is missing. The second tells the team how much rework lies ahead. That distinction changes the feel of a session. In tests-first mode, a red test is a normal intermediate state, and the agent can iterate against it without drama. In code-first mode, a red test arrives as a verdict on code that already exists, and the agent tends to patch symptoms instead of revisiting the design. To keep this advantage, the tests need to fail for the right reason. A test that fails because it references a missing helper, or because a fixture is broken, teaches the agent nothing except that the test is editable. Teams that review the suite before the implementation get the full benefit of the ordering; teams that accept both at once usually get a faster review and a weaker suite.

Implementation shrinks when the examples come first

Implementation becomes a consequence of the examples rather than a starting point. That sounds like a slogan, but it has practical effects on the diff. When tests come first, the diff tends to contain the smallest surface that satisfies them, because adding unused generality requires an example that does not exist. When code comes first, the diff tends to contain whatever abstractions the agent found plausible at the time. The tests-first order also gives the agent a natural place to stop: once the suite is green and the examples cover the promised behavior, further work needs a reason. Regression safety improves for an obvious reason, since the suite exists before the change and survives it. The remaining risk is a suite that mirrors the implementation rather than the requirement. Guard against that failure mode in review, and keep at least one example per behavior that a reader could verify by hand.

Judge agents by the tests they defend in review

Teams should evaluate an agent by the tests it is willing to defend. Ask which behaviors it chose to encode, which it left out, and what would make it write another example. Those answers separate a careful operator from a fast one. The order of the work is the cheapest lever available: asking for tests first costs a few minutes and buys a target, a set of visible decisions, and a debugging loop that spares the reviewer from reconstructing intent out of the diff. It is not magic and it will not rescue a vague prompt, but it turns ambiguity into questions instead of surprises.

BestRelay publishes this guidance as part of its work on quality-first agent workflows. It is a quality-first API relay that forwards each request to the official model named in it, with no substitution, covering Claude, GPT, Gemini, DeepSeek, Kimi, GLM, Qwen, Grok and more, and it works with Claude Code, Codex, Gemini CLI and any OpenAI SDK. Billing is pay-as-you-go from the token counts the provider reports, with cache reads and cache writes priced separately, and members earn a referral commission when people they invite top up. Model choice shapes the results here as well, and a precise model such as Claude Opus 5.5 tends to encode cleaner examples than a broad one. Create a BestRelay account to run your own tests-first sessions.