ralph-cycle

Execute a single Ralph development cycle by selecting a failing task, implementing it, verifying with tests, and committing. Use when ready to implement the next feature from the backlog.

14 stars

Best use case

ralph-cycle is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Execute a single Ralph development cycle by selecting a failing task, implementing it, verifying with tests, and committing. Use when ready to implement the next feature from the backlog.

Teams using ralph-cycle should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/ralph-cycle/SKILL.md --create-dirs "https://raw.githubusercontent.com/Biggy1606/ralph-wiggum-environments/main/windsurf/.windsurf/skills/ralph-cycle/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/ralph-cycle/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How ralph-cycle Compares

Feature / Agentralph-cycleStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Execute a single Ralph development cycle by selecting a failing task, implementing it, verifying with tests, and committing. Use when ready to implement the next feature from the backlog.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Ralph Development Cycle

This skill executes a single development cycle following the Ralph Wiggum Methodology: pick one task, implement it, verify it, commit it.

## Prerequisites

Before starting a cycle:

- ✅ `prd.json` exists with backlog
- ✅ `progress.md` exists
- ✅ `.windsurf/rules/tech-stack.md` exists

## Cycle Steps

### Step 1: Smart Context Selection

Read `prd.json` and `progress.md`. Analyze the backlog to determine the most logical next step.

**Selection Logic:** Do not simply pick the first item. Select the task that:

- Is currently failing (`passes: false`)
- Is unblocked by other tasks (dependencies are met)
- Makes the most sense to implement given the current state of the code

**Announce:** "I have selected [task name] because [reason]."

**Constraint:** PICK ONLY ONE TASK AT A TIME! Do not skip tasks unless blocked. If blocked, document the blocking reason in `progress.md`.

### Step 2: Planning & Journaling

Append a new entry to `progress.md` with the header "## Working on [Task Name]"

Write a brief plan of execution in the log including:

- What files will be modified/created
- What approach you'll take
- Any potential challenges
- How you'll verify completion

**Constraint:** Do not modify code yet.

### Step 3: Implementation

Implement the feature described in the selected task using the smallest change that satisfies the acceptance criteria.

**Constraints:**

- Work ONLY on this specific task
- Do not refactor unrelated code
- Modify only files required for the selected task
- Adhere to the standards in `.windsurf/rules/tech-stack.md`
- Follow the acceptance criteria from `prd.json`

### Step 4: Verification

Execute the verification command (e.g., `npm test`, `pytest`, etc.) relevant to this task.

Reference `.windsurf/rules/tech-stack.md` for the correct verification commands. If it does not list any, infer minimal verification and document it in `progress.md`.

**Retry Logic:**

If the command fails:

1. Read the error output
2. Attempt to fix the code
3. Re-run verification
4. Repeat up to 3 times

If it still fails after 3 tries, document the failure and next hypothesis in `progress.md`, then stop.

### Step 5: Completion & Commit

If verification passes:

1. Update `prd.json`: set `passes` to `true` for this task
2. Update `progress.md`: Append "**Result:** Success"
3. Run `git add .`
4. Run `git commit --no-gpg-sign -m "feat: [task description]"`

## Supporting Resources

Reference these files for guidance:

- `cycle-checklist.md` - Quick reference checklist
- `verification-examples.md` - Common verification patterns

## Anti-Patterns to Avoid

❌ Do not work on multiple tasks simultaneously
❌ Do not mark task as passing without running verification
❌ Do not commit code that fails tests
❌ Do not refactor unrelated code during implementation

Related Skills

We are still matching the closest adjacent skills for this page. In the meantime, continue through the full directory.