Ralph Isn't the Point. The PRD Is.

Ralph Wiggum, ready to code

I've been building an iOS app with AI coding tools, specifically using something called Ralph, which is basically a pattern for running AI CLIs in a loop. You write a PRD with acceptance criteria, set up a progress file, and run Claude Code (or whatever) repeatedly until the checklist is done. Matt Pocock wrote the definitive guide on it, and the name comes from The Simpsons because Ralph Wiggum is well-meaning but needs guardrails. Same energy.

Here's the strange part: it works. I kicked off a run, went to make coffee, and came back to working features committed to my repo. And here's the stranger part: the automation isn't the interesting bit.

The PRD is the real work

Before I could run Ralph, I had to write a PRD, and not a vague list of features but a proper document with acceptance criteria, verification steps, and a clear definition of done for each item. That PRD took real thought. I used Claude to help draft it, which meant I had to actually articulate what I wanted. What does "add tab bar navigation" mean, specifically? What are the tabs? What icons? What happens when you tap them? Where do the files go?

By the time the PRD was done... the hard work was finished.

Translating that spec into code was almost mechanical, and a junior engineer could have taken that PRD and produced roughly the same output as Ralph, just slower. Ralph's advantage isn't capability, it's speed and the fact that it doesn't get bored.

It's like passing your driving test using Tesla's autonomous mode. You technically passed, but you didn't learn what it's like to actually drive. If you skip the PRD and let the AI figure it out, you'll ship code, but you won't learn anything. (And honestly, I've been guilty of this. "Just make it work" is tempting when you're tired.)

The workflow works without AI too

Here's the contrarian take: Ralph is incidental, and the pattern underneath is what actually matters. PRD with acceptance criteria, small tasks, progress tracking, verification before commit. That workflow works whether Ralph executes it, a junior engineer executes it, or you execute it yourself. The AI is just one possible executor, a fast one sure, but the discipline is the asset, not the tool.

If Anthropic disappeared tomorrow, I'd keep the PRD template, I'd keep the checklist structure, and I'd keep the habit of defining done before writing code. Ralph gave me a reason to build that muscle, and the muscle stays even if Ralph goes.

The wrong question about AI replacing engineers

Everyone's asking "will AI replace engineers?" but that assumes there's a fixed amount of work to be done. Finish the backlog, ship the product, go home. That's not how software works. Work expands to fill capacity, and when you give engineers better tools they don't do the same work faster, they do more ambitious work.

I don't see Ralph replacing anyone. I see leverage. I see engineers freed up to do the work that actually requires judgment, things like architecture, requirements, and knowing what not to build.

The engineers who thrive won't be the ones racing against AI, they'll be the ones who know how to specify work clearly enough that AI can execute it. That's not a new skill, by the way. It's the old skill of writing good specs, delegation, and clear thinking. It's just more valuable now.

Ralph didn't replace anyone on my team. Ralph made me better at defining what needs to be built. (Which, honestly, I should have been better at anyway.)

Related

Credits