Archive / Other Writing
Hands-On with Claude Code + Ralph Loop
A structured Plan → Generate → Execute → Reflect → Refine loop that turns AI from a one-shot generator into a collaborative iterative engineer.
Published: Reading time: 3 min readEN
I recently experimented with the Claude Code plugin using the Ralph Loop workflow, and it noticeably changed how I approach iterative coding.
For those unfamiliar, Ralph Loop is a structured feedback loop:
Plan → Generate → Execute → Reflect → Refine → Repeat
Simple in theory. Powerful in practice.
Originally published on LinkedIn. Part 4 of a series — see design-driven AI development and architecture control.
What stood out from real usage
Tighter iteration cycles
Instead of prompting once and manually debugging, I let the loop critique outputs and propose refinements.
Quality improved dramatically after 2–3 iterations — not because the model got smarter, but because each pass fixed assumptions the previous pass hid.
Better reasoning transparency
Ralph Loop encourages intermediate reflection. This exposed flawed assumptions early — especially around edge cases and data handling.
When the model writes "this handles null inputs" in a reflection step, you can challenge it before it builds three files on a false premise.
Stronger test-driven behavior
Combined with small executable checks, the loop behaves almost like a lightweight autonomous dev assistant — writing, testing, and patching in cycles.
The test isn't optional decoration. It's the stop condition for each loop iteration.
Where it shines
| Use case | Why the loop helps |
|---|---|
| Refactoring legacy code | Each reflect step catches regressions before they compound |
| Generating API scaffolding | Plan stabilizes structure; iterations fill edge cases |
| Hardening business logic | Reflect pass explicitly hunts edge cases |
| Improving prompt-engineered agents | Same loop applies to agent configs and tool definitions |
Where caution is needed
Over-iteration leads to diminishing returns. After three passes, you're often polishing style, not fixing correctness.
Clear stopping criteria are essential. Define done upfront:
- All tests green
- No new files without plan approval
- Reflection finds no P0/P1 issues
Without stop rules, the loop optimizes forever.
Ralph Loop vs. Plan Mode vs. vibe coding
These workflows stack rather than compete:
- Plan Mode — decompose before touching code (high complexity)
- Ralph Loop — iterate with reflection inside an approved scope
- Spec-driven vibe — fast exploration when invariants are cheap to change
Example stack for a billing feature:
- Plan Mode for cross-module design
- Architecture contracts from context governance
- Ralph Loop for implementation + edge-case hardening
A minimal loop you can try today
- Plan — "List files, risks, and tests for X"
- Generate — smallest vertical slice only
- Execute — run tests / lint / typecheck
- Reflect — "What failed? What assumptions were wrong?"
- Refine — patch one issue at a time
- Repeat — max 3 cycles unless P0 remains
Log reflections in the PR description. Future you (and reviewers) see why the code looks the way it does.
Bottom line
Ralph Loop transforms AI from a "one-shot generator" into a collaborative iterative engineer.
The leverage isn't infinite automation. It's structured iteration — the same thing good human teams do in code review, compressed into minutes.
Pair it with design-first planning and architecture control, and you get speed without surrendering the system.