The Perfect Claude Code Plugin Pairing: ralph-loop + planning-with-files

Discovered by @LotusDecoder — a workflow combination that's quietly changing how developers use Claude Code for complex, multi-step automation.

---

If you've been using Claude Code for anything beyond quick, one-off tasks, you've probably run into a familiar frustration: the AI does great work in short bursts, but longer projects tend to drift — tasks get forgotten, progress resets between sessions, and you end up babysitting every step. Two official Claude Code plugins, ralph-wiggum/ralph-loop and skills/planning-with-files, directly solve this problem — and when used together, they form one of the most powerful autonomous workflow setups available right now.

Let's break down what each plugin does, why they complement each other so well, and how you can put this combination to work in your own projects.

---

What Is ralph-loop? The Autonomous Execution Engine

ralph-loop (from the ralph-wiggum plugin namespace) is essentially a supervision layer for Claude Code. Its core job is to keep Claude on task — looping through a defined set of objectives until completion, rather than waiting for you to re-prompt after every step.

Think of it as giving Claude Code a persistence mechanism. Without ralph-loop, Claude might complete the first subtask and then pause, waiting for you to confirm and redirect. With ralph-loop active, it continues executing — autonomously — checking its own output, handling errors when possible, and driving toward the end goal without constant human intervention.

Key behaviors ralph-loop enables:

• Continuous task execution without manual re-triggering
• Self-correction loops where Claude reviews its own outputs before proceeding
• Goal-oriented iteration — it keeps working until a defined completion condition is met
• Failure handling — rather than stopping at the first error, it attempts recovery strategies

For developers building automation pipelines, running code generation across large codebases, or orchestrating multi-file refactors, this loop behavior is a game changer. You can hand off a complex task, step away, and return to a completed (or substantially progressed) result rather than a stalled prompt waiting for your input.

---

What Is planning-with-files? The Progress Memory Layer

The skills/planning-with-files plugin tackles a different but equally important problem: Claude's lack of persistent memory across a long task.

By default, Claude Code works within a context window. For long sessions or complex projects, this means details from earlier in the conversation can get lost, priorities can shift, and you often end up re-explaining context you already covered. planning-with-files solves this by externalizing the planning process — writing structured task plans, progress notes, and status updates directly to files on disk.

Here's what that looks like in practice:

# Project Plan: Refactor Auth Module
Generated: 2025-07-15

## Tasks
- [x] Audit existing auth flow
- [x] Identify deprecated token methods
- [ ] Replace with OAuth2 implementation
- [ ] Update unit tests
- [ ] Update API documentation

## Notes
- Legacy session handler in /src/auth/session.js uses deprecated jwt lib
- New implementation should use jose library (v5+)
- Do not modify /src/middleware/cors.js — flagged for separate PR

This file becomes a living document. Claude reads it at the start of each step, updates it as tasks complete, and uses it to maintain context even as the conversation window shifts. For developers, this is especially powerful because:

• You get full visibility into what Claude has done and what's next
• Sessions are resumable — pick up exactly where you left off
• The plan file is version-controllable — commit it alongside your code
• It forces structured thinking before execution begins

Instead of Claude improvising its way through a task and losing track, planning-with-files anchors the work to a concrete, human-readable roadmap.

---

Why This Pairing Works: One Supervises, One Remembers

The reason ralph-loop + planning-with-files is such a natural pairing comes down to a simple division of responsibilities:

ralph-loop handles execution continuity. planning-with-files handles context continuity.

Neither plugin alone solves the full problem. ralph-loop keeps Claude working autonomously — but without planning-with-files, it can lose track of where it is in a complex plan, repeat steps, or miss dependencies. planning-with-files keeps the plan accurate and up-to-date — but without ralph-loop, you still need to manually trigger each step.

Together, they create a genuinely autonomous, self-aware execution loop:

1. Claude reads the plan file to understand current state
2. ralph-loop triggers the next task without waiting for human input
3. Claude executes the task, then updates the plan file with results
4. ralph-loop evaluates completion and moves to the next item
5. Repeat until all tasks are marked complete

This is the closest thing to a fully autonomous Claude Code agent you can set up today using official, supported tooling.

A Real-World Example: Automated Codebase Migration

Imagine you're migrating a Node.js project from CommonJS to ES Modules — a tedious, multi-file operation that's easy to get wrong.

With this plugin combination, your workflow might look like:

# Claude Code session startup
> Use ralph-loop and planning-with-files to migrate this project from CommonJS to ES Modules. 
  Start by creating a plan file, then execute each step in sequence.

Claude would:

• Generate migration-plan.md listing every file to modify, in dependency order
• Begin the loop, converting package.json first, then entry points, then modules
• Update the plan after each file — marking it complete, noting any issues
• Handle edge cases inline — flagging circular dependencies, skipping test files if instructed
• Finish with a summary of what changed, what needs manual review, and what's next

Without this pairing, the same task would require you to monitor progress, re-prompt Claude after each file, and manually track what's been done. With it, you can realistically walk away for 20 minutes and return to a largely completed migration with a full audit trail.

---

Getting Started: Setting Up the Plugin Pair

To enable both plugins in your Claude Code environment:

# Add ralph-loop plugin
claude plugin add ralph-wiggum/ralph-loop

# Add planning-with-files skill
claude plugin add skills/planning-with-files

When starting a complex task, explicitly tell Claude to use both:

Use ralph-loop for continuous execution and planning-with-files to track progress. 
Create a plan before starting, and update it after each step completes.

Pro tips for best results:

• Be specific about your completion criteria — tell Claude what "done" looks like so ralph-loop knows when to stop
• Set checkpoint intervals — ask Claude to write progress updates every N steps
• Review the plan file early — check it after the first step to ensure Claude interpreted your goal correctly before the loop runs long
• Keep tasks atomic — break your goal into small, testable steps so the loop can verify each one before continuing

---

Conclusion: A Workflow Worth Adding to Your Stack

The combination of ralph-loop and planning-with-files represents a meaningful step forward in how developers can leverage Claude Code for real, production-complexity work. One plugin keeps Claude working without constant hand-holding. The other keeps it oriented — aware of what's been done, what's left, and how the pieces connect.

For anyone building with Claude Code beyond simple scripts — think refactoring projects, documentation generation, test suite creation, or multi-service integration work — this pairing is worth experimenting with immediately.

Hat tip to @LotusDecoder for surfacing this combination. The original observation — that ralph-loop supervises task completion while planning-with-files faithfully tracks progress — is as concise and accurate a description of this pairing as you'll find. Sometimes the best developer insights come in a single sentence.

---

Found this useful? Explore more Claude Code workflows and AI automation resources at ClawList.io. Have a plugin combination worth sharing? We'd love to feature it.