Ralph Wiggum Loops: The Cross-Platform Implementation Guide

This guide expands on the original Ralph Wiggum technique with cross-platform implementations. You'll find working code for every major AI coding tool, actual cost breakdowns, and the gotchas that'll save you from expensive mistakes.

TL;DR

Ralph Wiggum is a bash loop that runs an AI coding agent repeatedly until tasks are complete.

while :; do claude -p "$(cat PROMPT.md)" ; done

Best platforms for overnight autonomous runs:

• Aider - Cheapest, excellent git integration
• Claude Code - Best quality, native plugin support
• OpenAI Codex - Free with ChatGPT Plus subscription
• Factory Droid - Enterprise-grade, top benchmark scores

Cursor requires manual scripting. GitHub Copilot works but has limitations.

---

Related Article11 min read

The Ralph Wiggum Technique: Ship Code While You Sleep

A developer left Claude Code running for three months. It built a working compiler. Here's the absurdly simple technique that's changing how...

Read full article

The Core Pattern (60-Second Refresher)

You feed an AI coding assistant the same task repeatedly. Each iteration sees the modified files from previous runs. The loop continues until either the task is done or you hit your iteration limit.

Most tools persist context between iterations. If you want true fresh starts, spawn new sessions per iteration (which bash loops do naturally).

Claude Code: The Reference Implementation

Let's set the record straight: "Ralph Wiggum" wasn't originally a plugin. It was a raw bash loop.

Huntley's original vision was punk rock: brute force autonomy by restarting the session entirely between every step. No shared memory buffer, no "agent state" to get corrupted—just the file system as the source of truth.

The Original Bash Loop (The "Pure" Ralph)

This is the technique in its rawest form. It works by forcing a full session restart (claude -p runs once and exits) for every iteration. This prevents the AI from getting confused by its own conversation history—it only sees what's actually on the disk.

#!/bin/bash # ralph-loop.sh - The original "brute force" technique TASK="Migrate all components from class-based to functional with hooks" MAX_ITERATIONS=20 ITERATION=0 # Create a prompt file (optional, but cleaner) echo "$TASK. Check previous changes in the files. Continue the work. Report 'TASK_COMPLETE' only when fully finished." > PROMPT.md while [ $ITERATION -lt $MAX_ITERATIONS ]; do ITERATION=$((ITERATION + 1)) echo "=== Iteration $ITERATION of $MAX_ITERATIONS ===" # The magic: -p runs non-interactively and EXITS after one turn. # This forces the model to re-read the file state fresh every time. claude -p "$(cat PROMPT.md)" 2>&1 | tee "logs/iteration-$ITERATION.log" # Check for completion signal if grep -q "TASK_COMPLETE" "logs/iteration-$ITERATION.log"; then echo "Task completed at iteration $ITERATION" exit 0 fi # Brief pause to avoid rate limits sleep 5 done echo "Max iterations reached"

The Plugin (Modern Convenience)

Eventually, the community wrapped this logic into ralph-wiggum@claude-plugins-official. Think of this as the "Safety Wrapper." It adds nice-to-haves like progress bars, cleaner logging, and safety limits, but underneath, it's just automating the restart cycle.

# If you prefer safety scissors over raw bash: claude plugin install ralph-wiggum@claude-plugins-official /ralph-loop "Migrate codebase" --max-iterations 20

Use the plugin if you want convenience. Use the bash loop if you want to understand what's actually happening.

Subscription vs. API Mode

Important context for new users: Claude Code operates differently depending on your account type.

• Pro Subscription ($20/mo): Many developers attempt loops on the standard Pro plan. While cost-effective, you will likely hit rate limits (45-50 messages every few hours) long before an overnight loop completes.
• Team Plan ($30/mo/user): Offers higher limits but still caps total usage.
• API (Pay-As-You-Go): This is the recommended method for Ralph Wiggum loops. By exporting ANTHROPIC_API_KEY, you bypass subscription caps and pay strictly for what you use. This is the only way to ensure your loop doesn't stall at 3 AM with a "Capacity Exceeded" error.

Cost Reality Check

I've run enough loops to give you real numbers (all costs in USD):

(That $150 ceiling on framework upgrades still stings. I hit it once on a React Router migration that could've been done manually in a day. Live and learn.)

One developer on X reported spending roughly $40 USD building a complete voice-to-voice app over 24-48 hours. That's not unreasonable for what would've been weeks of work.

But costs can spiral. Set spending alerts before you walk away.

Cursor: Getting Close, With Caveats

Cursor doesn't have a native "infinite loop" button like Claude Code, but its Composer feature (Command+I / Control+I) gets you 90% of the way there. It requires a human in the loop to click "Accept," but the iteration cycle is so fast that it feels nearly autonomous.

The "Accept-All" Loop (GUI Method)

For most developers, this is the most practical way to run a Ralph Wiggum loop today. You act as the confirmation mechanism, while Cursor handles the thinking and typing.

1. Open Composer: Press Cmd+I (Mac) or Ctrl+I (Windows) to open the multi-file agent.
2. Input the Mega-Prompt: Paste your task, but add a specific instruction:

> "Migrate all components in src/components to functional components. Do as many as you can in this pass. If you stop, I will prompt you to continue."

1. The Loop:

* Cursor will plan and edit multiple files.

* Click "Accept All": Once it pauses, accept the changes.

* Re-prompt: Immediately type "Continue" or "Check for missed files and keep going" in the same Composer window.

* Repeat until finished.

Zoom

Image could not be loaded: /images/articles/ralph-wiggum-cross-platform-cursor-copilot-2026/simpsons-drinking-bird-cursor-loop.gif

Actual footage of a Senior Engineer running a Cursor autonomous loop

While this technically counts as "babysitting," Cursor's speed makes it viable. You're not writing code; you're just pressing the "Next" button every 60 seconds. It's less "autonomous agent" and more "very enthusiastic junior dev who needs a thumbs-up."

Advanced: Headless Mode (Beta CLI)

For users with access to the experimental CLI tools (often gated behind waitlists or specific versions), Cursor offers a headless agent command. This effectively removes the human from the loop entirely.

> Note: If agent --version returns command not found, stick to the GUI method above.

# Non-interactive mode with -p flag agent -p "Add error handling to all API endpoints" \ --model claude-3-5-sonnet \ --output-format json # With force flag to skip confirmations agent -p --force "Refactor to TypeScript"

The -p flag runs in print mode (non-interactive). Use --force to allow changes without confirmation. Note: Windows users usually need WSL for this to function correctly.

The Gotchas

Context Window Fatigue: In the GUI loop, the Composer chat history grows rapidly. After 10-15 "Continue" loops, the context window fills up, and Cursor may start forgetting the original instructions.

* Fix: If performance degrades, start a fresh Composer session (Cmd+Shift+I) and ask it to "scan current status and resume work."

Model Hallucination: When pushing for speed, Cursor sometimes "edits" a file by deleting its entire content and replacing it with // ... rest of code.

* Fix: Always review the diffs (even quickly) before hitting "Accept All" in the GUI.

Aider: The Underrated Champion

Here's where things get interesting. Aider doesn't get the hype that Cursor or Claude Code get, but for autonomous loops? It might be the best tool for the job.

Native Auto-Commit Support

Aider was built for autonomous workflows from day one:

# Aider with autonomous features enabled aider --auto-commits \ --dirty-commits \ --watch-files \ --model claude-opus-4-5-20251101 # The magic flags: # --auto-commits: Commits after each successful change # --dirty-commits: Commits even with uncommitted changes # --watch-files: Monitors for AI comments (AI? and AI!) in code

The --watch-files mode is particularly clever. Aider monitors your codebase for special AI comments and responds to them automatically, creating a genuine feedback loop without external scripting.

Full Autonomous Configuration

Here's a production-ready Aider configuration for overnight runs:

#!/bin/bash # aider-overnight.sh # Set your model preference (Sonnet 4.5 is the sweet spot for cost/quality) export AIDER_MODEL="claude-sonnet-4-5-20250929" # Or use OpenAI for cost control # export AIDER_MODEL="gpt-5.2-codex" aider --auto-commits \ --dirty-commits \ --yes-always \ --no-suggest-shell-commands \ --map-tokens 2048 \ --max-chat-history-tokens 4000 \ --message "Complete the TODO items in this codebase. Work through them systematically, committing after each completion. Stop when no TODOs remain."

The --yes-always flag is key for autonomous operation. Aider won't pause for confirmations. (This is what I actually use for most of my overnight runs. The git integration alone saves me hours of cleanup.)

Why Developers Love Aider for This

Aider turns your terminal into what one developer called an "autonomous command centre." You specify the task, it handles the git workflow, and you review in the morning.

Aider Gotchas

Git conflicts in watch mode: When Aider's making rapid changes while you're also working, merge conflicts become inevitable. Use dedicated branches.

Cost overruns with premium models: Running Claude Opus 4.5 through Aider's extended sessions gets expensive fast. Most overnight runners use Sonnet 4.5 or GPT-5.2-Codex for cost control.

Model selection matters more: Aider's model-agnostic design means you feel quality differences more acutely. A loop that works beautifully with Opus might fail repeatedly with a cheaper model.

Aider Cost Comparison

Using OpenAI API directly through Aider:

The variability comes from task complexity and codebase size. Smaller, focused tasks hit the lower end. (I'm still figuring out optimal iteration counts for different task types. My rough rule: if you can't describe the task in two sentences, halve your iteration limit.)

GitHub Copilot: The Enterprise Reality

Here's the uncomfortable truth: GitHub Copilot wasn't originally built for Ralph Wiggum loops. But the newer Copilot CLI changes things. With some scripting, you can make it work.

Agent Mode with @workspace

Copilot's agent mode can handle multi-file tasks:

@workspace Analyse this codebase and add JSDoc comments to all exported functions @workspace Review the changes from my last commit and suggest improvements @workspace Create unit tests for the authentication module

The @workspace context gives Copilot visibility across your codebase, which is essential for autonomous work.

CLI Loop Workaround

GitHub's standalone copilot CLI (Agent Edition) supports programmatic mode with tool auto-approval. This makes Ralph Wiggum-style loops possible, though you'll need to script it yourself:

> Note: As of early 2026, this copilot executable is distinct from the gh copilot extension and requires the Enterprise "Copilot Native" beta access.

#!/bin/bash # copilot-loop.sh - Ralph Wiggum loop for GitHub Copilot CLI # Requires: copilot CLI installed (copilot.github.com) TASK="Add TypeScript types to all files in src/utils" MAX_ITERATIONS=15 ITERATION=0 while [ $ITERATION -lt $MAX_ITERATIONS ]; do ITERATION=$((ITERATION + 1)) echo "=== Iteration $ITERATION of $MAX_ITERATIONS ===" # Run Copilot in programmatic mode with auto-approval copilot -p "$TASK. Check previous changes and continue. Say 'TASK_COMPLETE' when done." \ --allow-all-tools \ 2>&1 | tee "logs/iteration-$ITERATION.log" # Check for completion signal if grep -q "TASK_COMPLETE" "logs/iteration-$ITERATION.log"; then echo "Task completed at iteration $ITERATION" exit 0 fi sleep 5 done echo "Max iterations reached"

The -p flag runs in programmatic (non-interactive) mode. The --allow-all-tools flag skips confirmation prompts, which is essential for unattended loops. For tighter security, use --allow-tool 'shell(git)' to allow only specific commands.

Important caveats: The Copilot CLI is still in preview, and context doesn't persist between -p invocations. Each loop iteration starts fresh, which can work for or against you depending on the task. You're also burning through your premium request quota with each iteration.

Why True Loops Are Harder Here

Enterprise restrictions: Copilot in enterprise environments often has guardrails that prevent extended autonomous sessions. IT policies matter.

Credit exhaustion: Several developers reported burning through their monthly Copilot allocation in the first week when using agent mode heavily.

Instruction adherence issues: Copilot agents sometimes ignore explicit instructions and start unauthorised tasks. That's terrifying for autonomous loops where you're not watching.

Best for: Teams that already have Copilot Enterprise licences and strict compliance requirements.

OpenAI Codex: The Official OpenAI Agent

OpenAI's Codex CLI is their answer to Claude Code. It's open source, built in Rust, and designed specifically for autonomous coding workflows. If you're already in the OpenAI ecosystem, this is probably what you should be using.

Non-Interactive Mode with `codex exec`

Codex has first-class support for scripted, autonomous operation through its exec command:

# Basic non-interactive execution codex exec "Add comprehensive error handling to all API endpoints" # Full autonomous mode with file write permissions codex exec --full-auto "Refactor the auth module to use async/await" # Maximum permissions (use in isolated environments only) codex exec --full-auto --sandbox danger-full-access \ "Migrate the test suite from Jest to Vitest"

The --full-auto flag enables autonomous operation without confirmation prompts. The --sandbox flag controls what Codex can access: workspace-write for normal development, or danger-full-access for CI/CD pipelines where you need broader permissions.

Building a Ralph Wiggum Loop

Here's a production-ready loop script for Codex:

#!/bin/bash # codex-loop.sh - Ralph Wiggum loop for OpenAI Codex CLI # Requires: npm i -g @openai/codex TASK="Add TypeScript types to all files in src/utils" MAX_ITERATIONS=15 ITERATION=0 while [ $ITERATION -lt $MAX_ITERATIONS ]; do ITERATION=$((ITERATION + 1)) echo "=== Iteration $ITERATION of $MAX_ITERATIONS ===" # Run Codex in non-interactive mode codex exec --full-auto --sandbox workspace-write \ "$TASK. Review previous changes and continue. Output 'TASK_COMPLETE' when finished." \ 2>&1 | tee "logs/iteration-$ITERATION.log" # Check for completion signal if grep -q "TASK_COMPLETE" "logs/iteration-$ITERATION.log"; then echo "Task completed at iteration $ITERATION" exit 0 fi sleep 5 done echo "Max iterations reached"

Subscription vs. API Mode

Be warned: If you use the CLI with a standard ChatGPT Plus login, you are subject to the same "50 messages every 3 hours" cap as the web UI. A Ralph loop can hit this in 30 minutes.

For overnight autonomy, configure the CLI with an API Key (OPENAI_API_KEY environment variable) to use the Pay-As-You-Go tier. It costs money, but it won't sleep when you do.

Session Continuity

Unlike some tools where each invocation starts fresh, Codex supports resuming previous sessions:

# Continue the last session codex exec resume --last "Fix the issues you found in the previous run" # Resume a specific session by ID codex exec resume abc123-session-id "Continue the migration"

This is useful for multi-stage workflows where you want to build on previous context rather than starting from scratch each iteration.

JSON Output for Automation

For CI/CD integration, Codex can output structured JSON:

# Stream events as JSON Lines codex exec --json "Analyse test coverage gaps" | jq '.type' # Write final message to file codex exec --full-auto -o ./summary.txt "Generate a PR description for these changes"

The --json flag outputs JSON Lines format, making it easy to pipe into other tools or parse programmatically.

Codex Pricing Reality

Codex is included with ChatGPT Plus, Pro, Business, Edu, and Enterprise plans. If you're already paying for ChatGPT, you've got Codex access. API-based usage follows standard OpenAI pricing, which tends to be competitive for GPT-5-Codex compared to Claude Opus.

Codex Gotchas

Git repository required: Codex won't run outside a git repo by default. Use --skip-git-repo-check if you really need to override this.

Windows support is experimental: Native Windows works but isn't fully stable. WSL is recommended.

Sandbox permissions matter: Running with danger-full-access in the wrong environment can cause real damage. Use isolated runners for CI/CD.

Codex is a serious contender for Ralph Wiggum loops. The exec command with session resume is arguably better designed for autonomous workflows than Claude Code's bash loop approach.

OpenCode: The Open Source Challenger

Here's the wildcard entry that's been climbing GitHub stars faster than anything I've seen this year. OpenCode is a fully open source AI coding agent built by the terminal.shop team, and it's positioning itself as the "no vendor lock-in" alternative to everything else on this list.

Why Developers Are Excited

The appeal is straightforward: OpenCode works with over 70 AI models across every major provider. Claude, GPT, Gemini, Groq, local models, whatever you've got. One tool, any brain.

Non-Interactive Mode for Scripting

OpenCode doesn't have native Ralph Wiggum loops built in, but it provides the primitives you need to build them yourself:

# Single prompt execution (non-interactive) opencode run "Add error handling to all API routes in src/api" \ -m anthropic/claude-sonnet-4-5 --format json # Chain into a loop with session continuity #!/bin/bash TASK="Add TypeScript types to all files in src/utils" # First iteration starts fresh opencode run "$TASK" -m anthropic/claude-sonnet-4-5 # Subsequent iterations continue the session for i in {2..15}; do echo "=== Iteration $i ===" opencode run "Continue. Check previous changes and proceed to next file. Say TASK_COMPLETE when done." \ -m anthropic/claude-sonnet-4-5 --continue 2>&1 | tee "logs/iteration-$i.log" if grep -q "TASK_COMPLETE" "logs/iteration-$i.log"; then echo "Task completed at iteration $i" exit 0 fi sleep 3 done

The run command executes non-interactively. Use -c or --continue to maintain context from the previous session. Use --session <id> to resume a specific session (find IDs with opencode session list). The --format flag supports default (formatted) or json (raw events).

Model format is provider/model-name. Use opencode models to see available models for your configured providers.

Using Existing Subscriptions

OpenCode lets you connect your existing ChatGPT Plus or Pro subscription, bypassing API costs entirely.

# Connect your ChatGPT subscription via CLI opencode auth login # Or inside the TUI, use the slash command > /connect # Select your provider from the interactive menu # Complete OAuth authentication in your browser

This makes extended sessions dramatically cheaper if you're already paying for a subscription. The connection persists across sessions once authenticated. Use opencode auth list to see connected providers.

Security Consideration

Fair warning: CVE-2026-22812 disclosed that versions before 1.0.216 had an unauthenticated HTTP server vulnerability. Make sure you're running a current version.

OpenCode Limitations

No native auto-commits: You'll need to handle git operations in your wrapper script.

No watch mode: Unlike Aider, it doesn't monitor file changes automatically.

Model quality variance: As one developer noted, "GLM-4.7 is near Opus 4.5" for free, but performance varies significantly between providers.

Best for: Developers who are comfortable writing wrapper scripts and want open-source freedom without subscription lock-in.

Factory Droid: The Enterprise Powerhouse

If you've been following AI coding benchmarks, you've probably seen Factory's Droid sitting at the top of Terminal-Bench. This isn't just marketing hype.

Droid scored 58.75% on Terminal-Bench, outperforming Claude Code (43.2%) and OpenAI's Codex CLI (42.8%) on the same models. That's not a minor improvement.

What Makes Droid Different

Factory built Droid specifically for autonomous operation from day one. The architecture includes:

Background execution primitive: Droid can start processes, keep working on other tasks, and leave builds or tests running. This is crucial for realistic development workflows.

Org and user-level memory: Context persists across sessions. Your Droids remember decisions, documentation, and run-books without you re-explaining every time.

Multi-model support in one interface: Switch between Claude Opus, GPT-5, Sonnet, or Factory's own GLM-4.6 without changing tools.

Autonomous Task Mode

For benchmarking, Factory runs Droid in "non-interactive task mode with all permissions skipped." That's effectively what you want for overnight Ralph Wiggum loops:

# Droid headless execution (use 'exec' not 'task') droid exec "Implement comprehensive test coverage for the auth module" \ --model claude-opus-4-5-20251101 \ --auto high \ --output-format json # Using a custom model configuration (e.g., GLM 4.6 Coding Plan) droid exec "Analyze dependencies and update outdated packages" \ --model custom:glm-4.6 \ --auto medium

The --auto high flag sets maximum autonomy (CI/CD level permissions). Three levels exist: low (safe edits only), medium (development work), and high (full autonomous operation including git push).

Enterprise Integration

Factory integrates with GitHub, GitLab, Jira, Slack, Linear, Notion, and Sentry. Your Droids have access to the same information human developers do, which makes autonomous work more context-aware.

The Real-World Test

One developer documented cancelling both Claude Max and ChatGPT Max subscriptions after switching to Factory. The key moment: a failing production database migration that Claude Code "kept circling the same dead ends" on. Droid with the same Opus 4.1 model on fresh context solved it "one shot."

Droid Gotchas

Token consumption: Several developers report "extremely fast" token usage, sometimes tens of thousands per request. Budget accordingly.

Enterprise pricing: Factory targets teams, not individual hobbyists. Pricing reflects that.

Learning curve: The power comes with complexity. Simpler tools might be better for straightforward tasks.

Best for: Enterprise situations where you need the highest benchmark performance and deep integration with tools like Jira and Linear.

Platform Comparison Matrix

Here's the decision table you actually want:

Quick Reference: Other Tools

A few more platforms worth mentioning briefly:

Cline (VS Code Extension)

Cline is a VS Code extension designed as human-in-the-loop. Important: There's no config file - settings are UI-only toggles stored in VS Code's GlobalState database.

Auto-approve toggles (all default OFF):

• Read/Edit project files
• Read/Edit all files
• Execute safe/all commands
• Use browser, MCP servers

For project guidance, create .clinerules in your project root:

# .clinerules (or .clinerules/ directory with multiple .md files) ## Coding Standards - Use TypeScript strict mode - All functions must have JSDoc comments - Run tests before committing

Full autonomous operation is available via "YOLO Mode" (Settings → Features → Enable YOLO Mode). This experimental mode disables all safety checks and user confirmations, letting Cline approve all actions automatically. Use with extreme caution. For headless CLI automation, you'll still need Claude Code or Aider, but YOLO mode works for unattended VS Code sessions.

Continue.dev

Open source option with Agent mode. Use `config.yaml` (not config.json or config.ts):

# .continue/config.yaml name: My Config version: 0.0.1 schema: v1 models: - name: Claude Sonnet 4.5 provider: anthropic model: claude-sonnet-4-5-20250929 apiKey: ${ANTHROPIC_API_KEY} roles: - chat - edit - apply

Agent mode is enabled through the UI mode selector (not configuration). For advanced programmatic config, use config.ts with export function modifyConfig(). Community-driven, so quality varies.

Amazon Q Developer

AWS's entry into the space. Decent for AWS-centric codebases, but loop support is minimal. Better for code generation than autonomous iteration.

The Pitfalls Nobody Warns You About

Let me save you some pain. These are the lessons from watching autonomous loops fail. I haven't tested every edge case on every platform, and I'm sure I've missed some failure modes. But these are the ones that got me.

Cost Disasters

The most common failure mode is walking away and coming back to a massive bill. I've seen developers report burning through credits that should've lasted months in a single night.

Prevention: Set hard spending limits before you start. Every platform has some form of budget controls. Use them. (If my cost estimates earlier are off for your specific use case, I'd genuinely like to know. Email me. This stuff changes weekly.)

The Infinite Loop of Doom

Sometimes an AI gets stuck. It makes a change, realises it broke something, reverts it, then makes the same change again. Forever.

Prevention: Always set max iterations. Start with 10-15 until you understand your task's complexity. Check logs for repetitive patterns.

Security Exposures

Running autonomous agents on codebases with credentials, API keys, or sensitive data is risky. One security researcher documented a "Reprompt" attack where malicious input in code could redirect Copilot to expose secrets.

Prevention: Never run autonomous loops on repos containing secrets. Use environment variables and secret managers. Review all changes before pushing.

The Confidence Trap

AI agents will confidently produce broken code that passes their own tests. They'll report "TASK_COMPLETE" when the task is very much not complete.

Prevention: Always have independent verification. Run your actual test suite, not just whatever the AI created. Human review before merge is non-negotiable.

Choosing Your Platform

Here's my honest recommendation by use case:

For pure autonomous overnight runs: Aider, Claude Code, Codex, or Droid. All four were designed for this. Aider has better cost control if you're API-price sensitive. Claude Code has excellent quality if you're committed to Anthropic. Codex is the natural choice if you're already paying for ChatGPT. Droid offers the best benchmark performance if you need enterprise features.

For team environments with existing VS Code infrastructure: Cursor, but accept that you'll need external scripting for true autonomous loops.

For cost-conscious developers: Aider with GPT-5.2-Codex, Codex with an existing ChatGPT subscription, or OpenCode with model flexibility.

For maximum model flexibility: OpenCode if you want to switch between 70+ models without changing tools. Droid if you need enterprise integrations alongside that flexibility.

For enterprise/compliance-heavy environments: Droid for best-in-class autonomous performance, Codex if you want OpenAI's official tooling, or Copilot if you must stay within Microsoft's ecosystem.

Key Takeaways

Claude Code, Aider, Codex, and Droid were built for autonomous loops. Cursor can get there with extra work. Copilot's better suited to other tasks.

Set spending limits before you start. Use dedicated branches. Keep secrets out of the repo. Human review before anything touches main.

The Ralph Wiggum technique works across platforms. Now you've got the code to try it on yours.

---