Skip to content

Commit 0710672

Browse files
jeffhjeffh
authored
feat(ralph): add ralph-loop that doesn't have permission bug (#57)
1 parent ddc597f commit 0710672

9 files changed

Lines changed: 753 additions & 0 deletions

File tree

‎.claude-plugin/marketplace.json‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,17 @@
4040
"email": "jeff@jeffhui.net"
4141
}
4242
},
43+
{
44+
"name": "ralph",
45+
"description": "Ralph Wiggum technique - iterative self-referential AI development loops using Stop hooks",
46+
"source": "./ralph",
47+
"category": "development",
48+
"version": "2025-01-03",
49+
"author": {
50+
"name": "Jeff Hui",
51+
"email": "jeff@jeffhui.net"
52+
}
53+
},
4354
{
4455
"name": "pai",
4556
"description": "Personal AI Infrastructure - 13 principles for deterministic, CLI-first AI with specialized agents and full history capture",

‎ralph/.claude-plugin/plugin.json‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
{
2+
"name": "ralph-wiggum",
3+
"description": "Implementation of the Ralph Wiggum technique - continuous self-referential AI loops for interactive iterative development. Run Claude in a while-true loop with the same prompt until task completion.",
4+
"author": {
5+
"name": "Anthropic",
6+
"email": "support@anthropic.com"
7+
}
8+
}

‎ralph/README.md‎

Lines changed: 179 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,179 @@
1+
# Ralph Wiggum Plugin
2+
3+
Implementation of the Ralph Wiggum technique for iterative, self-referential AI development loops in Claude Code.
4+
5+
## What is Ralph?
6+
7+
Ralph is a development methodology based on continuous AI agent loops. As Geoffrey Huntley describes it: **"Ralph is a Bash loop"** - a simple `while true` that repeatedly feeds an AI agent a prompt file, allowing it to iteratively improve its work until completion.
8+
9+
The technique is named after Ralph Wiggum from The Simpsons, embodying the philosophy of persistent iteration despite setbacks.
10+
11+
### Core Concept
12+
13+
This plugin implements Ralph using a **Stop hook** that intercepts Claude's exit attempts:
14+
15+
```bash
16+
# You run ONCE:
17+
/ralph-loop "Your task description" --completion-promise "DONE"
18+
19+
# Then Claude Code automatically:
20+
# 1. Works on the task
21+
# 2. Tries to exit
22+
# 3. Stop hook blocks exit
23+
# 4. Stop hook feeds the SAME prompt back
24+
# 5. Repeat until completion
25+
```
26+
27+
The loop happens **inside your current session** - you don't need external bash loops. The Stop hook in `hooks/stop-hook.sh` creates the self-referential feedback loop by blocking normal session exit.
28+
29+
This creates a **self-referential feedback loop** where:
30+
- The prompt never changes between iterations
31+
- Claude's previous work persists in files
32+
- Each iteration sees modified files and git history
33+
- Claude autonomously improves by reading its own past work in files
34+
35+
## Quick Start
36+
37+
```bash
38+
/ralph-loop "Build a REST API for todos. Requirements: CRUD operations, input validation, tests. Output <promise>COMPLETE</promise> when done." --completion-promise "COMPLETE" --max-iterations 50
39+
```
40+
41+
Claude will:
42+
- Implement the API iteratively
43+
- Run tests and see failures
44+
- Fix bugs based on test output
45+
- Iterate until all requirements met
46+
- Output the completion promise when done
47+
48+
## Commands
49+
50+
### /ralph-loop
51+
52+
Start a Ralph loop in your current session.
53+
54+
**Usage:**
55+
```bash
56+
/ralph-loop "<prompt>" --max-iterations <n> --completion-promise "<text>"
57+
```
58+
59+
**Options:**
60+
- `--max-iterations <n>` - Stop after N iterations (default: unlimited)
61+
- `--completion-promise <text>` - Phrase that signals completion
62+
63+
### /cancel-ralph
64+
65+
Cancel the active Ralph loop.
66+
67+
**Usage:**
68+
```bash
69+
/cancel-ralph
70+
```
71+
72+
## Prompt Writing Best Practices
73+
74+
### 1. Clear Completion Criteria
75+
76+
❌ Bad: "Build a todo API and make it good."
77+
78+
✅ Good:
79+
```markdown
80+
Build a REST API for todos.
81+
82+
When complete:
83+
- All CRUD endpoints working
84+
- Input validation in place
85+
- Tests passing (coverage > 80%)
86+
- README with API docs
87+
- Output: <promise>COMPLETE</promise>
88+
```
89+
90+
### 2. Incremental Goals
91+
92+
❌ Bad: "Create a complete e-commerce platform."
93+
94+
✅ Good:
95+
```markdown
96+
Phase 1: User authentication (JWT, tests)
97+
Phase 2: Product catalog (list/search, tests)
98+
Phase 3: Shopping cart (add/remove, tests)
99+
100+
Output <promise>COMPLETE</promise> when all phases done.
101+
```
102+
103+
### 3. Self-Correction
104+
105+
❌ Bad: "Write code for feature X."
106+
107+
✅ Good:
108+
```markdown
109+
Implement feature X following TDD:
110+
1. Write failing tests
111+
2. Implement feature
112+
3. Run tests
113+
4. If any fail, debug and fix
114+
5. Refactor if needed
115+
6. Repeat until all green
116+
7. Output: <promise>COMPLETE</promise>
117+
```
118+
119+
### 4. Escape Hatches
120+
121+
Always use `--max-iterations` as a safety net to prevent infinite loops on impossible tasks:
122+
123+
```bash
124+
# Recommended: Always set a reasonable iteration limit
125+
/ralph-loop "Try to implement feature X" --max-iterations 20
126+
127+
# In your prompt, include what to do if stuck:
128+
# "After 15 iterations, if not complete:
129+
# - Document what's blocking progress
130+
# - List what was attempted
131+
# - Suggest alternative approaches"
132+
```
133+
134+
**Note**: The `--completion-promise` uses exact string matching, so you cannot use it for multiple completion conditions (like "SUCCESS" vs "BLOCKED"). Always rely on `--max-iterations` as your primary safety mechanism.
135+
136+
## Philosophy
137+
138+
Ralph embodies several key principles:
139+
140+
### 1. Iteration > Perfection
141+
Don't aim for perfect on first try. Let the loop refine the work.
142+
143+
### 2. Failures Are Data
144+
"Deterministically bad" means failures are predictable and informative. Use them to tune prompts.
145+
146+
### 3. Operator Skill Matters
147+
Success depends on writing good prompts, not just having a good model.
148+
149+
### 4. Persistence Wins
150+
Keep trying until success. The loop handles retry logic automatically.
151+
152+
## When to Use Ralph
153+
154+
**Good for:**
155+
- Well-defined tasks with clear success criteria
156+
- Tasks requiring iteration and refinement (e.g., getting tests to pass)
157+
- Greenfield projects where you can walk away
158+
- Tasks with automatic verification (tests, linters)
159+
160+
**Not good for:**
161+
- Tasks requiring human judgment or design decisions
162+
- One-shot operations
163+
- Tasks with unclear success criteria
164+
- Production debugging (use targeted debugging instead)
165+
166+
## Real-World Results
167+
168+
- Successfully generated 6 repositories overnight in Y Combinator hackathon testing
169+
- One $50k contract completed for $297 in API costs
170+
- Created entire programming language ("cursed") over 3 months using this approach
171+
172+
## Learn More
173+
174+
- Original technique: https://ghuntley.com/ralph/
175+
- Ralph Orchestrator: https://github.com/mikeyobrien/ralph-orchestrator
176+
177+
## For Help
178+
179+
Run `/help` in Claude Code for detailed command reference and examples.

‎ralph/commands/cancel-ralph.md‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
---
2+
description: "Cancel active Ralph Wiggum loop"
3+
allowed-tools: ["Bash", "Read"]
4+
hide-from-slash-command-tool: "true"
5+
---
6+
7+
# Cancel Ralph
8+
9+
To cancel the Ralph loop:
10+
11+
1. Check if .claude/ralph-loop.local.md exists using Bash: test -f .claude/ralph-loop.local.md && echo "EXISTS" || echo "NOT_FOUND"
12+
2. **If NOT_FOUND**: Say "No active Ralph loop found."
13+
3. **If EXISTS**:
14+
- Read .claude/ralph-loop.local.md to get the current iteration number from the iteration: field
15+
- Remove the file using Bash: rm .claude/ralph-loop.local.md
16+
- Report: "Cancelled Ralph loop (was at iteration N)" where N is the iteration value

‎ralph/commands/help.md‎

Lines changed: 126 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,126 @@
1+
---
2+
description: "Explain Ralph Wiggum technique and available commands"
3+
---
4+
5+
# Ralph Wiggum Plugin Help
6+
7+
Please explain the following to the user:
8+
9+
## What is the Ralph Wiggum Technique?
10+
11+
The Ralph Wiggum technique is an iterative development methodology based on continuous AI loops, pioneered by Geoffrey Huntley.
12+
13+
**Core concept:**
14+
```bash
15+
while :; do
16+
cat PROMPT.md | claude-code --continue
17+
done
18+
```
19+
20+
The same prompt is fed to Claude repeatedly. The "self-referential" aspect comes from Claude seeing its own previous work in the files and git history, not from feeding output back as input.
21+
22+
**Each iteration:**
23+
1. Claude receives the SAME prompt
24+
2. Works on the task, modifying files
25+
3. Tries to exit
26+
4. Stop hook intercepts and feeds the same prompt again
27+
5. Claude sees its previous work in the files
28+
6. Iteratively improves until completion
29+
30+
The technique is described as "deterministically bad in an undeterministic world" - failures are predictable, enabling systematic improvement through prompt tuning.
31+
32+
## Available Commands
33+
34+
### /ralph-loop <PROMPT> [OPTIONS]
35+
36+
Start a Ralph loop in your current session.
37+
38+
**Usage:**
39+
```
40+
/ralph-loop "Refactor the cache layer" --max-iterations 20
41+
/ralph-loop "Add tests" --completion-promise "TESTS COMPLETE"
42+
```
43+
44+
**Options:**
45+
- `--max-iterations <n>` - Max iterations before auto-stop
46+
- `--completion-promise <text>` - Promise phrase to signal completion
47+
48+
**How it works:**
49+
1. Creates `.claude/.ralph-loop.local.md` state file
50+
2. You work on the task
51+
3. When you try to exit, stop hook intercepts
52+
4. Same prompt fed back
53+
5. You see your previous work
54+
6. Continues until promise detected or max iterations
55+
56+
---
57+
58+
### /cancel-ralph
59+
60+
Cancel an active Ralph loop (removes the loop state file).
61+
62+
**Usage:**
63+
```
64+
/cancel-ralph
65+
```
66+
67+
**How it works:**
68+
- Checks for active loop state file
69+
- Removes `.claude/.ralph-loop.local.md`
70+
- Reports cancellation with iteration count
71+
72+
---
73+
74+
## Key Concepts
75+
76+
### Completion Promises
77+
78+
To signal completion, Claude must output a `<promise>` tag:
79+
80+
```
81+
<promise>TASK COMPLETE</promise>
82+
```
83+
84+
The stop hook looks for this specific tag. Without it (or `--max-iterations`), Ralph runs infinitely.
85+
86+
### Self-Reference Mechanism
87+
88+
The "loop" doesn't mean Claude talks to itself. It means:
89+
- Same prompt repeated
90+
- Claude's work persists in files
91+
- Each iteration sees previous attempts
92+
- Builds incrementally toward goal
93+
94+
## Example
95+
96+
### Interactive Bug Fix
97+
98+
```
99+
/ralph-loop "Fix the token refresh logic in auth.ts. Output <promise>FIXED</promise> when all tests pass." --completion-promise "FIXED" --max-iterations 10
100+
```
101+
102+
You'll see Ralph:
103+
- Attempt fixes
104+
- Run tests
105+
- See failures
106+
- Iterate on solution
107+
- In your current session
108+
109+
## When to Use Ralph
110+
111+
**Good for:**
112+
- Well-defined tasks with clear success criteria
113+
- Tasks requiring iteration and refinement
114+
- Iterative development with self-correction
115+
- Greenfield projects
116+
117+
**Not good for:**
118+
- Tasks requiring human judgment or design decisions
119+
- One-shot operations
120+
- Tasks with unclear success criteria
121+
- Debugging production issues (use targeted debugging instead)
122+
123+
## Learn More
124+
125+
- Original technique: https://ghuntley.com/ralph/
126+
- Ralph Orchestrator: https://github.com/mikeyobrien/ralph-orchestrator

‎ralph/commands/ralph-loop.md‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
---
2+
description: "Start Ralph Wiggum loop in current session"
3+
argument-hint: "PROMPT [--max-iterations N] [--completion-promise TEXT]"
4+
allowed-tools: ["Bash(${CLAUDE_PLUGIN_ROOT}/scripts/setup-ralph-loop.sh)"]
5+
hide-from-slash-command-tool: "true"
6+
---
7+
8+
# Ralph Loop Command
9+
10+
Execute the setup script to initialize the Ralph loop:
11+
12+
```bash
13+
"${CLAUDE_PLUGIN_ROOT}/scripts/setup-ralph-loop.sh" $ARGUMENTS
14+
```
15+
16+
Execute the above command using Bash, then work on the task. When you try to exit, the Ralph loop will feed the SAME PROMPT back to you for the next iteration. You'll see your previous work in files and git history, allowing you to iterate and improve.
17+
18+
CRITICAL RULE: If a completion promise is set, you may ONLY output it when the statement is completely and unequivocally TRUE. Do not output false promises to escape the loop, even if you think you're stuck or should exit for other reasons. The loop is designed to continue until genuine completion.

‎ralph/hooks/hooks.json‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
{
2+
"description": "Ralph Wiggum plugin stop hook for self-referential loops",
3+
"hooks": {
4+
"Stop": [
5+
{
6+
"hooks": [
7+
{
8+
"type": "command",
9+
"command": "${CLAUDE_PLUGIN_ROOT}/hooks/stop-hook.sh"
10+
}
11+
]
12+
}
13+
]
14+
}
15+
}

0 commit comments

Comments
 (0)