Ralph and Coding Agent Escape Velocity
It's getting more expensive to use agents well.
It’s hard to write a newsletter every week when you take two weeks off. My strategy for this has been to write shorter pieces focused on one simple idea.
This piece will talk about “Ralphing” (an effective way of using coding agents) and the impact it may have on software development.
Ralph is this idea by Geoffrey Huntley to run the same prompt repeatedly in a loop until it is done.
It's the ultimate way to double down on one-shotting coding tasks especially applicable for long-term tasks running overnight.
Typically when you try to one shot a task with Claude or another coding agent, it will give an earnest go over a number of iterations but may eventually stop. This could be because it wants to preserve credits, or it ran into a loop or it blew out its context or some other excuse.
“Ralph” circumvents that by repeating the Claude loop over and over with a fresh context every time (minus whatever code was created in the current folder). Doing this has been surprisingly effective. To speculate why:
Performance naturally degrades at larger context windows so the hard reset is helpful;
Using Ralph encourages user prompts to direct coding agents to write more self-contextualizing code (context is in the repo/comments) which is a good practice in general for performance and autonomous development; Note this implies your first Ralph may not work as well;
Most people get in the way of agents instead of helping them effectively through a task.
Steve Yegge (yes! Steve) then followed this up with my favorite post of 2026 so far: Welcome to Gas Town. In this post, he predicts that software engineers will inevitably become orchestrators of several agents in parallel.
He also makes this image covering a concept I'd loosely described before in The Delegation Window and Limits to Vibe Coding.
Here is his framework:
First, you should locate yourself on the chart. What stage are you in your AI-assisted coding journey?
Stage 1: Zero or Near-Zero AI: maybe code completions, sometimes ask Chat questions
Stage 2: Coding agent in IDE, permissions turned on. A narrow coding agent in a sidebar asks your permission to run tools.
Stage 3: Agent in IDE, YOLO mode: Trust goes up. You turn off permissions, agent gets wider.
Stage 4: In IDE, wide agent: Your agent gradually grows to fill the screen. Code is just for diffs.
Stage 5: CLI, single agent. YOLO. Diffs scroll by. You may or may not look at them.
Stage 6: CLI, multi-agent, YOLO. You regularly use 3 to 5 parallel instances. You are very fast.
Stage 7: 10+ agents, hand-managed. You are starting to push the limits of hand-management.
Stage 8: Building your own orchestrator. You are on the frontier, automating your workflow.
The claim: it's inevitable that software engineers of the future have more in common with the Party Poker grinders of 2010 than anyone else.
As we all work our way up this curve, it does have a fundamental bottleneck that is not skill related: money.
At a certain point you need more cash to support workloads. So you need a job or business that generates ROI on the code you produce.
And this is an interesting phenomenon.
While coding agents are making coding much more accessible initially, in the future, software engineers may be stratified at very different tiers.
Some will be foot soldiers and others will be air force pilots, piloting $1M of credit a year.
Similar to how runaway companies that can get the LTV > CAC equation to work in their favor can hyper-scale, I suspect the coming decade will be dominated by companies and individuals who can get positive ROI on their coding credits.