How to grind through issues — with a stubborn coding loop plus review gate.

Short, stubborn, effective. Like Ralph.

The same prompt runs against Claude Code over and over. The agent reads the open issue files, picks the next ticket, implements it with TDD, commits, next round. On the next pass it sees its own latest commits and keeps going until nothing's left.

The name is the punchline: Ralph Wiggum from The Simpsons. Dumb but stubborn-effective. The loop doesn't make grand decisions, it just picks the next ticket. Because it does that a thousand times in a row, the feature is finished at the end.

# once.sh — one iteration
issues=$(cat issues/*.md)
commits=$(git log -n 5 --format="%H%n%ad%n%B---" --date=short)
prompt=$(cat ralph/prompt.md)
claude --permission-mode acceptEdits "Previous commits: $commits Issues: $issues $prompt"

That's all of it. prompt.md says: pick issue, TDD, all tests green before commit, move finished ticket to issues/done/. Done state via file move, no status flag. Very clean.

That's also exactly its limit. Matt says it honestly in the workshop: "I don't honestly know what the answer to this yet. We just need to be ready to be doing more code review." The loop produces code faster than you can read it. For throwaway prototypes that's fine — for software real people are supposed to use, code review is the bottleneck. That's where my wrapper comes in.

How my tuned Ralph runs in practice.

The loop isn't the whole project — it's the development pass per issue. A phase (for me e.g. "Spurwert MVP") is 15–25 issues. Every issue goes through the same pass. How the issues come into being before the phase — strategy, PRD, issue cutting — is a different story and not the topic here.

The update tasklist from the session: seven Ralph-core steps, framed by four wrapper steps.

What I do differently, and why.

Per dimension: standard Ralph, my setup, Sand Castle. So you can actually compare instead of reading three lists side by side.

Wave Auto in live test. Sand Castle as the premium upgrade.

The sequential pass from section 03 now runs through my /wave skill — it wraps branch-per-issue and the review gate instead of me starting wrapper.sh by hand. Since 30 May 2026 the new mode Wave Auto is the default there: instead of working through several issues manually in sequence or across parallel chats, one master prompt runs in a single chat and spawns N subagents — hands-off, with a self-fix loop and a compliance check that verifies per subagent whether the PR was merged and the report was written.

The pattern is reproducible without my skill: 1 master prompt → N subagents, each handed exactly one file-disjoint issue (TDD → PR → self-review → merge → short report). The master waits for all reports, checks each against ground truth (PR really merged? report really there?) and self-fix-loops whatever comes back red. That's the real evolution of the parallel swarm I'd only hinted at before. Alongside it there's /swarm as an auto mode and /wave parallel for when I'd rather babysit N chats myself. The precondition stays the same: file-disjoint issues, otherwise merge hell.

If you want it as a finished product: Sand Castle by Matt Pocock (v0.7.0, May 2026, ~5.7k stars) is the tested industry variant — provider-agnostic (Docker/Podman/Vercel), multi-agent, merger pipeline built in. Heavier setup, more token cost, but nothing to maintain yourself. For me right now not the right ratio — as long as I build alone, Wave Auto gets close to the same effect without the overhead. Worth keeping an eye on for the day when issue volume or review load justify it.

As of June 2026 — updated here when something changes.