Ralph++: Max out your Claude Max!

# Ralph++

You've got Claude Max. You've got unlimited messages. You've got higher rate limits and extended thinking.

Time to take the limiters off.

## What Claude Max Gives You

| Feature | Free/Pro | Max | Ralph Impact |
|---------|----------|-----|--------------|
| Messages | Limited | Unlimited | Run all night, every night |
| Rate limits | Standard | 5x higher | Faster iterations |
| Extended thinking | Limited | Full | Better planning, fewer mistakes |
| Context window | 200K | 200K | Same, but you can burn it freely |

Ralph++ is Ralph optimized for Max subscribers. More aggressive, more parallel, more autonomous.

## The Ralph++ Loop

```bash
#!/bin/bash
# ralph++.sh - Claude Max optimized

set -euo pipefail

TASK_FILE="${1:-PROMPT.md}"
MAX_ITERATIONS="${MAX_ITERATIONS:-200}"      # Go big
PARALLEL_AGENTS="${PARALLEL_AGENTS:-3}"       # Run multiple
THINK_BUDGET="${THINK_BUDGET:-high}"          # Let it cook
MIN_DELAY=1                                   # Max can handle it

echo "🚀 Ralph++ initialized"
echo "   Task: $TASK_FILE"
echo "   Max iterations: $MAX_ITERATIONS"
echo "   Parallel agents: $PARALLEL_AGENTS"
echo "   Think budget: $THINK_BUDGET"

ITERATION=0
STUCK_COUNT=0
LAST_HASH=""

while [ $ITERATION -lt $MAX_ITERATIONS ]; do
    ITERATION=$((ITERATION + 1))

    echo ""
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo "  Iteration $ITERATION/$MAX_ITERATIONS @ $(date +%H:%M:%S)"
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

    # Run with extended thinking enabled
    OUTPUT=$(cat "$TASK_FILE" | claude \
        --continue \
        --dangerously-skip-permissions \
        2>&1) || true

    echo "$OUTPUT"

    # Check completion
    if echo "$OUTPUT" | grep -q "TASK_COMPLETE"; then
        echo ""
        echo "✅ TASK_COMPLETE after $ITERATION iterations"
        echo "   Total time: $SECONDS seconds"
        exit 0
    fi

    # Check if blocked
    if echo "$OUTPUT" | grep -q "TASK_BLOCKED"; then
        echo ""
        echo "🚧 TASK_BLOCKED - check BLOCKERS.md"
        exit 2
    fi

    # Stuck detection (more lenient for Max)
    CURRENT_HASH=$(git diff --stat 2>/dev/null | md5sum | cut -d' ' -f1)
    if [ "$CURRENT_HASH" = "$LAST_HASH" ]; then
        STUCK_COUNT=$((STUCK_COUNT + 1))
        if [ $STUCK_COUNT -ge 5 ]; then
            echo "⚠️  No progress for 5 iterations - injecting nudge"
            echo -e "\n\n---\nYou seem stuck. Try a different approach. Read error messages carefully." >> "$TASK_FILE.tmp"
            cat "$TASK_FILE" >> "$TASK_FILE.tmp"
            mv "$TASK_FILE.tmp" "$TASK_FILE"
            STUCK_COUNT=0
        fi
    else
        STUCK_COUNT=0
        LAST_HASH=$CURRENT_HASH
    fi

    # Minimal delay - Max can handle the throughput
    sleep $MIN_DELAY
done

echo "🛑 Max iterations reached"
exit 1
```

## Extended Thinking Mode

Claude Max gives you full extended thinking. Use it.

```markdown
## Thinking Instructions

Before implementing, think through:
1. What could go wrong?
2. What are the edge cases?
3. What's the simplest solution that satisfies all requirements?

Take your time. I'd rather you think for 60 seconds and get it right
than rush and iterate 10 times.
```

When Claude has thinking budget, it plans better. Fewer iterations overall.

## Parallel Agents

Why run one loop when you can run three?

```bash
#!/bin/bash
# parallel-ralph.sh - Multiple agents, one codebase

# Split tasks into independent chunks
TASKS=(
    "PROMPT_auth.md"
    "PROMPT_api.md"
    "PROMPT_ui.md"
)

# Launch in parallel
for task in "${TASKS[@]}"; do
    echo "Launching agent for $task"
    ./ralph++.sh "$task" &
done

# Wait for all
wait
echo "All agents complete"
```

Rules for parallel Ralph:
- Tasks must be independent (no file conflicts)
- Each agent gets its own branch
- Merge at the end

```bash
# Branch per agent
git checkout -b agent/auth
./ralph++.sh PROMPT_auth.md
git checkout main && git merge agent/auth

git checkout -b agent/api
./ralph++.sh PROMPT_api.md
git checkout main && git merge agent/api
```

## 24-Hour Autonomous Runs

With Max, you can let Ralph run overnight. Here's the setup:

### 1. Notification on Completion

```bash
# Add to ralph++.sh after TASK_COMPLETE
curl -X POST "https://ntfy.sh/your-channel" \
    -d "Ralph++ finished: $TASK_FILE in $ITERATION iterations"
```

Or use the system notification:

```bash
osascript -e 'display notification "Ralph++ done!" with title "Task Complete"'
```

### 2. Auto-Commit Progress

```markdown
## Progress Protocol

After each successful change:
1. Stage changes: `git add -A`
2. Commit with message: `git commit -m "wip: [what you did]"`
3. Continue to next requirement

This ensures progress is saved even if the loop is killed.
```

### 3. Morning Summary

```bash
# At the end of ralph++.sh
echo "=== Ralph++ Summary ===" > SUMMARY.md
echo "Iterations: $ITERATION" >> SUMMARY.md
echo "Duration: $SECONDS seconds" >> SUMMARY.md
echo "Commits:" >> SUMMARY.md
git log --oneline -20 >> SUMMARY.md
```

## Dangerously Skip Permissions

For fully autonomous runs, use the nuclear option:

```bash
claude --dangerously-skip-permissions
```

This lets Claude:
- Write files without asking
- Run commands without confirmation
- Make git commits automatically

**Only use this when:**
- You're on a feature branch
- You have good test coverage
- You can review/revert in the morning

## Cost? What Cost?

Claude Max is unlimited messages. The only limit is rate limits, and Max has 5x higher limits.

Run as many iterations as you need. Let it loop. Let it learn.

I've had Ralph++ runs go 150+ iterations overnight. Woke up to a working feature and a clean git history.

## The Ralph++ PROMPT.md Template

```markdown
# Task: [Specific task]

## Context
- This is a Ralph++ run (extended thinking enabled, high iteration budget)
- Take your time on planning, be thorough on implementation
- You have unlimited retries, but aim to converge quickly

## Requirements
- [ ] Requirement 1
- [ ] Requirement 2
- [ ] Requirement 3

## Validation
ALL must pass:
- `make test`
- `make lint`
- `make build`

## Completion Protocol
When done:
1. Ensure all tests pass
2. Commit: `git add -A && git commit -m "feat: [task]"`
3. Output exactly: TASK_COMPLETE

## Progress Saves
After each meaningful change:
- Commit with `wip: [description]`
- This saves progress across iterations

## If Blocked
1. Document blocker in BLOCKERS.md
2. Output: TASK_BLOCKED
3. Do not loop forever on impossible tasks

## Session State
1. `git log --oneline -5` - recent commits
2. `git status` - current state
3. Continue from where you left off
```

## When to Use Ralph++

- **Overnight feature builds** - Wake up to PRs
- **Large refactors** - Let it grind through 50 files
- **Test coverage campaigns** - "Add tests until coverage > 80%"
- **Migration tasks** - Repetitive, verifiable, perfect for loops

## Philosophy

Regular Ralph is about iteration. Ralph++ is about *scale*.

You're not babysitting anymore. You're managing a fleet.

Set the task. Set the constraints. Let the loop handle it.

Then go to sleep.