Braintrust moved half its engineering team to Codex in a month by collapsing the feature-request backlog

What Braintrust actually changed in its workflow

Braintrust builds an observability and evaluation platform for AI products. According to OpenAI's account, its engineers now use Codex with GPT-5.5 to take a customer feature request, spin up a preview branch, and show a working version back to the customer in minutes.

The concrete before-and-after is the part worth noting. Founder and CEO Ankur Goyal describes the old path: a request would 'enter a backlog and get prioritized later.' The new path is a copy-paste into Codex, a preview branch, and a live demo. The queue step is gone, at least for the class of requests small enough to prototype on the spot.

OpenAI reports that half the Braintrust team moved to Codex within one month. That adoption number is the headline metric in the story, and it's the only hard figure offered—there are no throughput or cycle-time numbers behind it.

Goyal's claim is about latency, not capability

The story is unusually direct about what made the difference, and it isn't reasoning quality. It's speed. Goyal frames it as a property that changes his behavior, not just his output rate.

It sounds simple, but Codex can literally print more text in the terminal without getting slow, and other models just can't replicate that. The biggest gain is speed.Montana Labs

That is a narrow, testable claim: sustained terminal output without slowdown. For a team iterating in front of a customer, tool latency is not cosmetic—it decides whether a request gets prototyped in the meeting or written down for later. Goyal says the speed 'changes the way I interact with Codex compared to other models,' which is the mechanism behind the backlog claim rather than a separate benefit.

A shift from prompting to sandboxed autonomy

The second workflow change described is more specific to engineering practice. Goyal says that with slower tools he had to 'prompt the model to solve a specific problem'—hands-on, step-by-step guidance. With Codex he instead writes a test that demonstrates the problem, sets up a sandbox environment, and lets the agent run inside it.

He calls this 'a novel use case for me,' and explicitly ties it to speed: 'I can run experiments because of the speed.' The logic is that when each iteration is cheap enough, defining a problem via a failing test and letting the agent iterate becomes viable where careful prompting was previously required. This is a fitting pattern for an eval company—demonstrating a problem with a test is exactly the kind of specification an evaluation-minded team already produces.

The specific implication: fast agents change what enters the backlog, not just how fast it clears

The reflexive reading of this story is 'AI makes coding faster.' The more precise takeaway is that a low enough iteration latency changes the decision about whether to attempt a request at all. Braintrust didn't just accelerate work already in the queue—it dissolved the trade-off that sends small requests into a queue in the first place.

For teams evaluating agentic coding tools, that reframes the benchmark. The question is less 'can the model solve the task' and more 'is the round-trip fast enough that engineers change their working habits.' Braintrust's own conclusion, in Goyal's words, is quantity-driven: 'The more code we write, the more customer problems we can solve.' That is a bet that cheap iteration compounds—one that this single customer story asserts through adoption and testimony rather than measured output, so the durability of the pattern is still an open question worth watching in teams' own metrics.