A two-week check-in on how developers (and non-developers) are having fun with autonomous AI coding. Even the CEO of Notion is in on the Ralph train.

8 min readJust now

–

Press enter or click to view image in full size

Ralph showing us plebs how it’s done.

A few weeks ago, I wrote about the Ralph Wiggum loop — that deceptively simple technique where you stick Claude Code in a bash loop and let it grind through your codebase until the job’s done. The response was… a lot (it’s actually my most viral story to date). People started building things. Weird things. Useful things. Things I didn’t expect.

So I figured it was time for a check-in. What happens when you hand the keys to Ralph and walk away?

Turns out, quite a bit.

A Quick Refresher: What’s Ralph Again?

If you missed my original explainer, here’s the short version.

Ralph Wiggum is a technique. In its purest form, it’s embarrassingly simple:

while :; do cat PROMPT.md | claude-code ; done

That’s it. You give Claude Code a task, and when it tries to stop, the loop feeds the prompt back in. The files Claude just changed are still there, so each iteration builds on the last. You cap the loop with a max iteration count or a “completion promise” that Claude outputs only when the task is truly done.

Press enter or click to view image in full size

That simple.

Geoffrey Huntley, who popularised the technique, puts it plainly: “Ralph is a Bash loop.”

The name comes from that scene in The Simpsons where Ralph Wiggum sits in a burning room, cheerfully declaring “I’m in danger!” — which captures the feeling of watching an AI autonomously modify your codebase at 2am.

The beauty of Ralph is that it’s deterministically bad in an undeterministic world.

That quote from Huntley might sound like a dig, but it’s actually the point. Ralph has defects. It makes mistakes. But those mistakes are identifiable and fixable through better prompts. You tune Ralph like a guitar, adding guardrails until it stops falling off the slide.

People Are Having Actual Fun With This

What’s surprised me most in the last two weeks isn’t the technical achievements — it’s the vibe. People are genuinely enjoying themselves.

The copywriter loop. @koylanai built what he called “Ralph Wiggum Copywriter” — a loop that learns your voice, critiques its own work, and rewrites until it’s actually good. His post got 1,500+ likes and 2,000 bookmarks. The self-critique loop, he said, “hits different.”

The Notion CEO got involved. Ivan Zhao (@ivanhzhao) saw Geoffrey Litt’s setup for managing coding agents on a Kanban board — where blocked tasks turn red to alert you — and simply replied: “Ralph Wiggum x Kanban.” That tweet pulled 73,000 views.

When the CEO of Notion is posting about your meme technique, you know something’s shifted.

Extensions for everything. The community didn’t stop at Claude Code:

• @sashimikun_void built a Ralph Wiggum extension for Gemini CLI
• @galdawave created “Pickle Rick” — a Gemini CLI extension that automates his entire software development lifecycle. His manual workflow? “Officially retired.”
• @hmemcpy built a Ralph generator that supports both Claude and Amp Code

And it’s not just individual developers. VentureBeat ran a story titled “How Ralph Wiggum went from ‘The Simpsons’ to the biggest name in AI right now.” The Dev Interrupted podcast interviewed Geoffrey Huntley about inventing the technique.

A Simpsons character is now a legitimate topic at tech conferences. We live in strange times.

The Forks Worth Knowing About

When a technique catches fire, people start building proper tools around it. Two repos stand out.

Ralphy by Michael Shimeles (github.com/michaelshimeles/ralphy)

This one’s interesting because it’s not just a Claude Code wrapper. Ralphy supports multiple AI engines: Claude Code, OpenCode, Codex, and Cursor. You can read tasks from a PRD file, YAML, or even GitHub Issues.

The killer feature? Parallel execution with isolated git worktrees. Each agent gets its own branch (ralphy/agent-1-task-name, ralphy/agent-2-task-name, etc.) and its own directory. When they’re done, branches merge back automatically — or you can have Ralphy create pull requests for each completed task.

@Rasmic shared his Ralphy setup:

# Full mode with tests and linting./ralphy.sh​# Skip tests only./ralphy.sh --no-tests​# Fast mode - skip both tests and linting./ralphy.sh --fast

It’s got 134 stars and 19 forks. Small but growing fast.

Ralph Claude Code by Frank Bria (github.com/frankbria/ralph-claude-code)

Press enter or click to view image in full size

This is the heavyweight implementation. 3,300 stars, 215 forks, 308 passing tests. It’s what happens when you take the Ralph concept and build enterprise-grade guardrails around it.

The standout feature is intelligent exit detection. Version 0.9.9 introduced a dual-condition check: the loop only exits when both completion indicators fire and Claude explicitly signals EXIT_SIGNAL: true. This fixed a bug where Ralph would quit early while Claude was still productive.

Other features include:

• Rate limiting with hourly reset (100 calls/hour by default)
• Circuit breaker patterns to prevent runaway loops
• Session continuity across iterations
• tmux integration for live monitoring
• PRD import functionality — convert existing requirements docs into Ralph-friendly format

There’s also Ralph Orchestrator by @mikeyobrien, which @trustinvibe described as “the industrial grade version” — adding token tracking, spending limits, and git checkpointing.

Press enter or click to view image in full size

When Non-Programmers Start Ralphing

This is where things get weird. In a good way.

“Vibe coding” has been floating around for a while — that style of development where you describe what you want in plain English and let AI handle implementation. Ralph takes vibe coding to its logical extreme: write a PRD, set up the loop, go to sleep, wake up to… something.

Sometimes that something is brilliant. Sometimes it’s a mess. But the barrier to entry has collapsed.

Reddit threads are full of people saying things like: “I’m not a developer by trade, but Claude Code has allowed me to build things I never thought possible.”

The workflow looks like this:

1. Write a detailed PRD in plain English
2. Set up a Ralph loop with appropriate limits
3. Let Claude work overnight
4. Review in the morning

One user built three working apps in a month without knowing how to code. Another automated a tedious data processing workflow that used to eat hours of their week.

The barriers are real — you still need basic terminal familiarity, API costs stack up ($20–200+ for complex projects), and debugging AI-generated code without understanding it is tricky. But the walls are lower than they’ve ever been.

The Ralph Wiggum Loop provides the persistence needed for the long-mission coding tasks of the future.

That’s from a Substack post titled “Why Every Wiggum Loop Needs a Principal Skinner”, which argues that autonomous loops still need human oversight, but the division of labour is shifting.

Did Cursor Just… Ralph?

Okay, I wasn’t going to make this claim lightly. But then @swyx said the quiet part loud:

“Cursor independently invented the ralph wiggum loop to solve the problems they were seeing with parallel agent orchestration.”

That tweet pointed to Cursor’s blog post about scaling long-running autonomous coding. And then, a few days later, Cursor dropped something wild.

@mntruell (Cursor co-founder Michael Truell) announced they’d built a browser. A complete, from-scratch browser. 3+ million lines of code across thousands of files. Custom rendering engine in Rust. HTML parsing, CSS cascade, layout, text shaping, paint, and a custom JavaScript VM.

They let GPT-5.2 run uninterrupted for one week.

“It kind of works! It still has issues and is of course very far from Webkit/Chromium parity, but we were astonished that simple websites render quickly and largely correctly.”

The post got 4.5 million views and 8K likes.

Now, Cursor hasn’t explicitly said “we Ralph Wiggum’d a browser into existence.” But the pattern is unmistakable: a long-running autonomous agent, working iteratively through a massive task, building on its own output. That’s Ralph. Whether they call it that or not.

The Wild ROI Stories

The numbers people are sharing? Borderline absurd.

Geoffrey Huntley posted an iMessage screenshot (shared with permission) from someone who used Ralph on a contract:

“Cost of a $50k USD contract, delivered, MVP, tested + reviewed with Amp. $297 USD.”

A Y Combinator hackathon team put Ralph to the test and documented what happened: they shipped 6+ repositories overnight for $297 in API costs.

Huntley himself has been running Ralph for three consecutive months to build “Cursed” — a complete esoteric programming language with Gen Z slang as keywords. slay for function. sus for variable. based for true. It has LLVM compilation to native binaries, a standard library, and partial editor support. An actual, production-grade language built almost entirely by a loop.

Building software with Ralph requires a great deal of faith and a belief in eventual consistency. Ralph will test you.

That’s from Huntley’s blog. He’s not wrong.

Getting Better at Ralph (Matt Pocock’s Tips)

@mattpocockuk (of Total TypeScript fame) wrote a guide on AI Hero called “11 Tips For AI Coding With Ralph Wiggum.” If you’re serious about using Ralph, it’s worth reading.

The core advice echoes what the community has learned through trial and error:

Be specific in your prompts. Vague instructions lead to wandering loops. Clear, verifiable goals lead to convergence.

Set boundaries. Define what’s in scope and what’s out. Ralph will happily implement features you didn’t ask for if you don’t tell it not to.

Include examples. Show expected inputs and outputs. Ralph learns from context.

Use the exit signals properly. The dual-condition exit (completion indicators + explicit signal) exists for a reason. Let Claude tell you when it’s actually done.

Monitor, don’t abandon. Ralph isn’t fire-and-forget for complex projects. Check in. Review the diffs. Catch it before it goes down a rabbit hole.

Geoffrey Huntley’s philosophy is even simpler: every time Ralph does something wrong, don’t blame the tool — look at the prompt. Tune Ralph like a guitar. Add signs to the playground. Eventually, you get a new Ralph that doesn’t feel defective at all.

What’s Next?

Ralph Wiggum is barely six months old, and look at what’s happened. Extensions for multiple AI engines. Enterprise-grade implementations with 300+ tests. A browser built in a week. A programming language built in three months.

And that’s just the public stuff. The private projects, internal tools, contract work delivered at 100x ROI — that’s a much bigger iceberg.

The technique will keep evolving. Better exit detection. Smarter guardrails. Fancier parallelisation. But the core insight stays the same: put an AI in a loop, give it clear goals, let it iterate.

Ralph Wiggum sat in that burning room and said “I’m in danger!” We’re sitting in our terminals watching Claude rewrite our codebases at 3am, whispering the same thing.

And somehow, it’s working.

This is a follow-up to Ralph Wiggum, explained: the Claude Code loop that keeps going.

References

• Geoffrey Huntley’s Ralph Wiggum page: ghuntley.com/ralph
• Ralphy by Michael Shimeles: github.com/michaelshimeles/ralphy
• Ralph Claude Code by Frank Bria: github.com/frankbria/ralph-claude-code
• Matt Pocock’s Ralph tips: aihero.dev
• Y Combinator hackathon field report: repomirror.md
• VentureBeat coverage: “How Ralph Wiggum went from ‘The Simpsons’ to the biggest name in AI right now”
• Dev Interrupted podcast: “Inventing the Ralph Wiggum Loop | Creator Geoffrey Huntley”

Tweets referenced:

• @koylanai: Ralph Wiggum Copywriter
• @ivanhzhao: Ralph x Kanban
• @sashimikun_void: Gemini CLI extension
• @galdawave: Pickle Rick extension
• @hmemcpy: Ralph generator
• @Rasmic: Ralphy setup
• @swyx: Cursor and Ralph
• @mntruell: Cursor browser project
• @cursor_ai: GPT-5.2 announcement
• @mattpocockuk: Ralph tips guide
• @trustinvibe: Ralph Orchestrator
• @unsatchmo: RalphWiggum harness generator