ralph
Autonomous feature development - setup and execution. Triggers on: ralph, set up ralph, run ralph, run the loop, implement tasks. Two phases: (1) Setup - chat through feature, create tasks with dependencies (2) Loop - pick ready tasks, implement, commit, repeat until done.
Profile →npx skills add majiayu000/claude-skill-registry --skill ralph --agent claude-code
Same command for any agent — swap --agent for codex, cursor, copilot.
Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.
What it does
Automates feature development in two modes: setting up new features by chatting to define tasks and dependencies, or wiring up existing tasks for Ralph to execute. It guides the user to choose a mode, asks clarifying questions, breaks the feature into properly sized tasks, and orders them with dependsOn relationships. It creates a parent task and subtasks, saves a parent-task-id, and then archives and resets progress as part of a final setup. It also includes a loop phase where Ralph picks ready leaf tasks based on the dependency graph, executes them, and advances until completion.
How it works
- Mode selection: prompts user to choose between creating a new feature or using existing tasks.
- Step 1 Understand: asks the user what feature is being built and clarifying questions until enough detail exists to break into tasks.
- Step 2 Break Into Tasks: ensures each task fits into one Ralph iteration; suggests task types and enforces small scope.
- Step 3 Order by Dependencies: documents the typical sequence (schema/database → server/backend → UI → tests) and uses dependsOn to order tasks.
- Step 4 Create Tasks: creates a parent task with a title/description, then creates subtasks with parentID and dependencies, including a repoURL. Requires confirming acceptance criteria and typecheck expectations in descriptions.
- Step 5 Set Up Ralph Files: saves parent task ID to scripts/ralph/parent-task-id.txt and archives a previous progress.txt as needed, then creates a fresh progress.txt.
- Step 6 Confirm Setup: presents a summary of created tasks and how to start Ralph (run ralph or start the loop).
- Final Setup: a set of commands to verify saved IDs, progress reset, and subtasks existence.
When to use it
- When starting a new feature and you want structured task planning with dependencies.
- When you have existing tasks and want to configure Ralph to run them in order.
What it can touch
- Prerequisites include a connected repository (repoURL in tasks) and usage of the task_list tooling. It references files under scripts/ralph and expects task IDs to be saved there for Ralph to run.
Caveats
- Tasks must be small enough to be completed in a single Ralph iteration; otherwise they should be split.
- Ralph uses dependsOn to enforce ordering and will only proceed to the next task when dependencies are satisfied.
- Final setup requires saving parent-task-id.txt and resetting progress.txt; archiving is conditional based on content.
# Ralph Feature Setup Interactive feature planning that creates ralph-ready tasks with dependencies. --- ## The Job **Two modes:** ### Mode 1: New Feature 1. Chat through the feature - Ask clarifying questions 2. Break into small tasks - Each completable in one iteration 3. Create task_list tasks - Parent + subtasks with `dependsOn` 4. Set up ralph files - Save parent ID, reset progress.txt ### Mode 2: Existing Tasks 1. Find existing parent task - Search or let user specify 2. Verify structure - Check subtasks have proper `dependsOn` 3. Set up ralph files - Save parent ID to parent-task-id.txt 4. Show status - Which tasks are ready, completed, blocked **Ask the user which mode they need:** ``` Are you: 1. Starting a new feature (I'll help you plan and create tasks) 2. Using existing tasks (I'll set up Ralph to run them) ``` --- ## Step 1: Understand the Feature Start by asking the user about their feature. Don't assume - ASK: ``` What feature are you building? ``` Then ask clarifying questions: - What's the user-facing goal? - What parts of the codebase will this touch? (database, UI, API, etc.) - Are there any existing patterns to follow? - What should it look like when done? **Ke
- The Job
- Mode 1: New Feature
- Mode 2: Existing Tasks
- Step 1: Understand the Feature
- Step 2: Break Into Tasks
- Right-sized tasks:
- Too big (split these):
- Step 3: Order by Dependencies
- Step 4: Create Tasks
- First, create the parent task:
- Then, create subtasks with parentID and dependsOn:
- Task description format:
- Step 5: Set Up Ralph Files
- Step 6: Confirm Setup
echo "<parent-task-id>" > scripts/ralph/parent-task-id.txt cat scripts/ralph/parent-task-id.txt cat scripts/ralph/progress.txt mkdir -p scripts/ralph/archive/$DATE-$FEATURE cp scripts/ralph/progress.txt scripts/ralph/archive/$DATE-$FEATURE/ echo "Archived to scripts/ralph/archive/$DATE-$FEATURE/" cat > scripts/ralph/progress.txt << 'EOF' Confirm parent ID is saved Confirm progress.txt is reset head -10 scripts/ralph/progress.txt
What does the ralph skill do?
Autonomous feature development - setup and execution. Triggers on: ralph, set up ralph, run ralph, run the loop, implement tasks. Two phases: (1) Setup - chat through feature, create tasks with dependencies (2) Loop - pick ready tasks, implement, commit, repeat until done.
How do I install it?
Run `npx skills add majiayu000/claude-skill-registry --skill ralph --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.
Where does this skill come from?
From majiayu000/claude-skill-registry, a repository with 534 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.
Is a popular skill a good skill?
Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.