The man spends over a billion tokens a day. That’s roughly $1,000 in compute. And he hasn’t touched a code editor in nine months.
Ryan Leapo, Member of Technical Staff at OpenAI, walked onto a London stage and delivered a message that should make every software engineer in the room uncomfortable: code is free now. Implementation is no longer the scarce resource. The only thing that matters is how you orchestrate the agents to do the job.
This isn’t a vision. It’s his daily operation.
The Paradigm Shift No One Wants to Admit
Leapo’s thesis is brutal in its simplicity: GPT 5.2 marked the moment models became “isomorphic” to human engineers. They can produce code that solves real problems in real codebases at high quality. Not perfect code. Acceptable code. And in a world where acceptable code is infinitely abundant, everything about how we organize teams changes.
The numbers back this up. His three-person team produces three to five pull requests per day. Each engineer effectively has access to “five, 50, or 5,000 engineers worth of capacity 247 every day of the year.” The constraint isn’t talent. It’s GPU capacity and token budgets.
Think about what that means for project planning. In a world where human time to write code is scarce, you stack-rank everything. P0s get done. P2s might. P3s never happen. In Leapo’s world, all those P3s get kicked off immediately—maybe four in parallel. You pick the one that works. The rest get discarded.
This is the practical meaning of “code is free.” You no longer optimize for code production. You optimize for code selection.
The New Job: Systems Thinking and Delegation
Here’s what Leapo actually does all day. He doesn’t write code. He writes tickets. He writes documentation. He builds the infrastructure that lets agents operate.
His team starts with a ticket. That’s the entry point. The ticket goes to an agent along with a set of “skills”—essentially prompts that teach Codex how to launch the app, spin up the observability stack, boot Chrome DevTools, attach to the application. The entire local development environment is designed for the agent to invoke it, not the human.
This is the crucial inversion. Instead of building tools for humans to use, you’re building tools for agents to use. The human’s job shifts to defining what good looks like, not doing the work.
The scarce resources now are three things: human time, human and model attention, and model context window. Leapo’s advice: figure out where your time is going, automate the synchronous parts, and move into higher-leverage activities. Your job is to be a staff engineer with as many team members as you can drive concurrently—limited only by tokens.
The Code Review Revolution
This is where most teams get stuck. You build an agent. It writes code. You still feel compelled to read every line before merging. That’s the old pattern. Leapo’s team broke it.
They noticed that with three engineers producing 15 PRs a day, merge conflicts were killing them. PRs stayed open too long because humans were the bottleneck. So they automated code review the same way they automated everything else.
Every engineer spends Fridays on what they call “garbage collection day.” Their entire job: take every piece of slop observed over the week that made PRs hard to merge, and figure out ways to categorically eliminate it. This closes the loop between human feedback and agent behavior. Patterns get documented. Reviewer agents get triggered on every push. The documentation surfaces automatically via failing tests or reviewer agents primed with the docs.
The result: slop reduces, reduces, reduces. Humans step out of the loop entirely.
Leapo puts it plainly: “Every time I have to type continue to the agent is like a failure of the harness to provide enough context around what it means to continue to completion.”
The Car Setup and the Real Point
There’s a photo floating around Twitter of Leapo strapping his laptop into the back of his car so he can keep running inference during his commute. He kicks off a task before leaving the office, tethers his laptop to his phone, and lets it cook for the 30-minute drive home.
The point isn’t the car. It’s that he doesn’t interact with the agents at all. The skills tell the agent: you’re operating on this task, go until tests are green. The dream is 50 agents running 24/7 with zero human interaction.
This is what “full job” actually means. Not “agent helps me write code faster.” Agent does the entire software engineering job from ticket to merged PR while the human does… what, exactly?
Leapo’s answer: higher-level, squishier activities. Triaging user feedback. Triaging pages. Making sure no PII is leaking in production logs. Writing runbooks for user operations staff. Moving that into code so the problems don’t happen in the first place. The meta-programming part of the job—defining processes and acceptance criteria that let agents do everything else.
The Future He’s Building Toward
The feature Leapo wants to build toward: take a token budget and a quarter’s worth of work, input success metrics and reliability metrics, and let the machines continually advance the product forward without his hands on the wheels.
The parts of software engineering that weren’t originally designed for agents—QA smoke testing on built artifacts, for example—need new tools. His team had to build tools for agents to download built artifacts, launch them, and validate critical user journeys. There’s a whole universe of engineering outside of writing code, and agents can do it all if you document what good looks like.
The bitter lesson, Leapo says, is that context management won’t be obsoleted by model improvements. Models must be told the requirements. Models must be told which guardrails to pay attention to. The harness’s job is surfacing the right instructions at the right time.
That’s the durable skill. Not code. Prompt design. Documentation. System design for agents.
The Takeaway
Leapo’s talk is either the most optimistic or most terrifying thing you’ll hear this year, depending on where you sit in your career. The shift isn’t coming. It’s here. His team of three produces more merged code than most teams of fifteen—and he hasn’t touched an editor since last summer.
The question isn’t whether agents can do your job. The question is whether you can do the new one: the systems thinker, the documentation architect, the person who figures out how to productively deploy infinite code capacity into problems worth solving.
Code is free. Your attention isn’t.