gemini-cli-ralph-wiggum

KO | EN

gitlite — search

#hacktoberfest #react #typescript #llm #machine-learning #rust #linux #java #windows #kubernetes #awesome-list #pytorch #security #open-source

gemini-cli-ralph-wiggum

(★ 12)

Ralph Wiggum extension for Gemini CLI

gemini-cli-ralph-wiggum 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Ralph Wiggum Gemini Extension

Implementation of the Ralph Wiggum technique for iterative, self-referential AI development loops in the Gemini CLI.

## What is Ralph?

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.

The technique is named after Ralph Wiggum from The Simpsons, embodying the philosophy of persistent iteration despite setbacks.

### Core Concept

This extension implements Ralph using an `AfterAgent` stop hook that intercepts the agent's exit attempts. It creates a **self-referential feedback loop** where:

- The prompt never changes between iterations.
- Gemini's previous work persists in files.
- Each iteration sees modified files and git history.
- Gemini autonomously improves by reading its own past work in files.

```bash
# You run ONCE:
/ralph-loop "Your task description" --completion-promise "DONE"

# Then Gemini CLI automatically:
# 1. Works on the task
# 2. Tries to exit
# 3. Stop hook blocks exit
# 4. Stop hook feeds the SAME prompt back
# 5. Repeat until completion
```

## Installation

```bash
gemini extensions install https://github.com/jackwotherspoon/gemini-cli-ralph-wiggum
```

## Quick Start

```bash
/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
```

Gemini will:
- Implement the API iteratively.
- Run tests and see failures.
- Fix bugs based on test output.
- Iterate until all requirements met.
- Output the completion promise when done.

## Commands

### `/ralph-loop`

Start a Ralph loop in your current session.

**Usage:**
```bash
/ralph-loop "<prompt>" --max-iterations <n> --completion-promise "<text>" [--debug]
```

**Options:**
- `--max-iterations <n>` - Stop after N iterations (default: unlimited).
- `--completion-promise <text>` - Phrase that signals completion. Must be wrapped in `<promise>` tags in the model's output.
- `--debug` - Enable debug logging to the project's `.gemini/ralph-debug.log`.

### `/cancel-ralph`

Cancel the active Ralph loop (removes the state file).

**Usage:**
```bash
/cancel-ralph
```

## Prompt Writing Best Practices

### 1. Clear Completion Criteria

❌ Bad: "Build a todo API and make it good."

✅ Good:
```markdown
Build a REST API for todos.

When complete:
- All CRUD endpoints working
- Input validation in place
- Tests passing (coverage > 80%)
- README with API docs
- Output: <promise>COMPLETE</promise>
```

### 2. Incremental Goals

❌ Bad: "Create a complete e-commerce platform."

✅ Good:
```markdown
Phase 1: User authentication (JWT, tests)
Phase 2: Product catalog (list/search, tests)
Phase 3: Shopping cart (add/remove, tests)

Output <promise>COMPLETE</promise> when all phases done.
```

### 3. Self-Correction

❌ Bad: "Write code for feature X."

✅ Good:
```markdown
Implement feature X following TDD:
1. Write failing tests
2. Implement feature
3. Run tests
4. If any fail, debug and fix
5. Refactor if needed
6. Repeat until all green
7. Output: <promise>COMPLETE</promise>
```

### 4. Escape Hatches

Always use `--max-iterations` as a safety net to prevent infinite loops on impossible tasks:

```bash
# Recommended: Always set a reasonable iteration limit
/ralph-loop "Try to implement feature X" --max-iterations 20
```

**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.

## When to Use Ralph

**Good for:**
- Well-defined tasks with clear success criteria.
- Tasks requiring iteration and refinement (e.g., getting tests to pass).
- Greenfield projects where you can walk away.
- Tasks with automatic verification (tests, linters).

**Not good for:**
- Tasks requiring human judgment or design decisions.
- One-shot operations.
- Tasks with unclear success criteria.
- Production debugging (use targeted debugging instead).

## Philosophy

Ralph embodies several key principles:

1.  **Iteration > Perfection**: Don't aim for perfect on the first try. Let the loop refine the work.
2.  **Failures Are Data**: "Deterministically bad" means failures are predictable and informative. Use them to tune prompts.
3.  **Operator Skill Matters**: Success depends on writing good prompts, not just having a good model.
4.  **Persistence Wins**: Keep trying until success. The loop handles retry logic automatically.

## Real-World Context

The Ralph Wiggum technique has been shown to be effective for autonomous development:
- Successfully generated multiple repositories overnight in hackathon settings.
- Enables "set and forget" development for well-scoped tasks.
- Demonstrates that persistence and self-correction can overcome single-shot model limitations.

## Learn More

- Original technique: [https://ghuntley.com/ralph/](https://ghuntley.com/ralph/)
- Ralph Orchestrator: [https://github.com/mikeyobrien/ralph-orchestrator](https://github.com/mikeyobrien/ralph-orchestrator)
- Inspired by the Claude Code Plugin: [https://github.com/anthropics/claude-code/tree/main/plugins/ralph-wiggum](https://github.com/anthropics/claude-code/tree/main/plugins/ralph-wiggum)

gemini-cli-ralph-wiggum

gemini-cli-ralph-wiggum 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

gemini-cli-ralph-wiggum

gemini-cli-ralph-wiggum 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README