20 loops in this category.
Turn the open issue backlog into a proposed two-week sprint plan with estimates, a dependency ordering, and an explicit cut line, written as a document for the team to edit.
/goal SPRINT-PLAN.md contains a proposed 2-week plan — read all open issues labeled `ready`, estimate each as S/M/L based on the code it touches, order them by dependency and value, draw a cut line at a realistic capacity, and list what falls below it with reasons; make no changes to the issues themselves; stop after 6 turns
/ralphnew
Three starter CLI tools that turn loop design into a repeatable workflow: scaffold a loop with a goal, budget, and verify step; audit an existing loop design; and estimate cost before you run.
Starter CLI tools: `loop-init` scaffolds a loop (goal, budget, verify step), `loop-audit` reviews an existing loop design, `loop-cost` estimates spend before running.
The canonical Ralph loop: each iteration starts fresh, reads the PRD and guardrails, ships exactly one backlog item end-to-end, and records what it learned.
/loop start each iteration with fresh context: read PROMPT.md, prd.json, and .ralph/guardrails.md; pick the single highest-priority item in prd.json not marked done, implement it with tests, run the full check suite, commit and mark it done only if green; if blocked or a check fails twice the same way, append the lesson to .ralph/guardrails.md and move on; stop when every item is done or after 30 turns
/ralphnew
A two-vendor loop that pairs Claude as architect with Codex as builder, using the repo itself as shared memory: the architect writes specs, the builder implements one item per iteration, and the architect reviews the diffs on the next pass.
Claude as architect, Codex as builder, the repo as shared memory — architect writes plan/spec files, builder implements one item per iteration, architect reviews diffs next pass.
/ralphnew
A graduated path to unattended Ralph runs: start with a single bounded task, add a PROMPT.md spec file, add verification, and only then remove the human from the loop for overnight builds.
Staged path from basic prompt → PROMPT.md spec → overnight Ralph run: start with a single bounded task, add a spec file, add verification, only then remove the human from the loop.
Twice a week, scan new GitHub issues for duplicates of existing ones and link them with a polite comment and a duplicate label, closing nothing automatically.
/schedule every Tuesday and Friday at 10am, compare issues opened in the last 4 days against existing open issues; when one is a likely duplicate, comment with a link to the original and apply the `possible-duplicate` label, but never close anything yourself
/schedulenew
Every weekday at 9am, label new GitHub issues from the last 24 hours by area and priority and post a one-line summary on each.
/schedule every weekday at 9am, label new issues from the last 24h by area and priority, and post a one-line summary on each
/goalnew
Set an explicit condition on the task, and the agent verifies completion against that goal instead of generic heuristics.
/goal <condition sets an explicit completion condition on the active task. NextSpeakerJudgeGuardian switches from generic "is the turn finished?" to strict goal-aware evaluation that verifies the transcript shows demonstrable evidence the condition is met. AGENT-only. Available in TUI and IntelliJ. Condition persisted on the tasks table, survives session restart
/ralphnew
Execute Plan-Act-Test-Review-Iterate cycles on a goal until it succeeds, pauses, blocks, or token budget exhausts.
/goal <objective — a persistent objective that survives sessions and runs the Ralph Loop (Plan → Act → Test → Review → Iterate) until the goal is achieved, paused, cleared, blocked ( unmet ), or the token budget is exhausted
/goalnew
Implement each GOALS.md phase with tests and validation, committing and pushing after stable milestones until unblocked.
/goal Complete GOALS.md phases 1-13 in order. For each phase, implement the deliverables, add/update tests, run the common validation plus that phase's Automated QA, commit after the phase passes, and push after stable milestones. Preserve unrelated user changes. Stop only if blocked by missing credentials, external service access, or an explicit product decision that cannot be safely inferred
Sponsored · ConnectMyEmailLoops that read your inbox.
Email is the missing tool in your harness. ConnectMyEmail gives Claude Code and Codex a clean MCP into Gmail, Outlook, iCloud and IMAP — triage, drafts, follow-ups, on a loop.
connectmyemail.com → /goalnew
Define a goal for Hermes to work toward across multiple turns until it's achieved.
/goal [text|sub] Set a standing goal Hermes works on across turns until achieved
/ralphnew
A fact-checked knowledge base of Claude Code creator Boris Cherny's loop methodology, packaged as a runnable agent-loop skill you can drop straight into Claude Code.
Fact-checked knowledge base of Cherny's loop methodology for running Claude Code, shipped as a runnable `agent-loop` skill in `skill/agent-loop/`.
/ralphnew
A plan-the-loop-first skill: it interviews you about the automation idea, previews the flow as ASCII art, and only writes final loop artifacts after you confirm — a safe on-ramp for loop beginners.
Skill interviews you about the automation idea, writes loop artifacts to `looper-output/`, shows an ASCII flow preview, and only finalizes after you confirm — design the loop before any runner touches files.
A design framework for AI agent loops built on three questions — when should it run (schedule), what does done mean (goal), and who does the isolated pieces (subagents) — with worked examples in Claude Code and Codex.
Design framework: choose schedule (when), goal (what done means), subagents (who does isolated pieces) — with worked examples in Claude Code and Codex.
/goalnew
Run an agent toward a condition, pausing and resuming across sessions with structured goal, progress, and blocker files.
/goal <condition that sets a lightweight stop-condition: after each turn the harness checks whether the condition is met and auto-continues until it is. That primitive has no state files, no acceptance criteria, no iteration log. This skill ( /pursue ) is the heavyweight version: structured goal.md / progress.md / blockers.md , a self-paced ScheduleWakeup loop, and explicit pause/resume/stop lifecycle. Use the built-in for "keep going until X is true" within a session; use /pursue for multi-day work that must survive resets
/loopnew
Dig deeper into asset classes until you identify true winners, re-analyzing every 2 hours.
/loop 2h keep going and dig deeper until you find us true winners per asset class
The spec-driven maturation of the Ralph loop: each fresh-context iteration reads PLAN.md, implements the highest-priority unchecked item, checks it off, and commits — so the spec file evolves alongside the codebase.
Ralph variant where the loop prompt is "read PLAN.md, pick highest-priority unchecked item, implement, check it off, commit, exit" — spec file evolves with the codebase.
/goalnew
Work through each phase in your roadmap, verify each one, run the final audit, and stop when all phases pass.
/goal "Execute all phases of <run-root /ROADMAP.md sequentially. Read <run-root /phases/phase-N.md for each phase; do the work; run mandatory commands; print SUPERGOAL PHASE VERIFY then SUPERGOAL PHASE DONE for each phase; follow the failure-recovery protocol in <run-root /PROTOCOL.md if any criterion fails. After the last phase, run the FINAL AUDIT in <run-root /PROTOCOL.md (re-verify against <run-root /ROADMAP.md; re-run aggregated mandatory commands; spot-check criteria; on gaps, write <run-root /phases/audit-fix-<round .md and execute inline). Only after AUDIT COMPLETE, print SUPERGOAL RUN COMPLETE. Done when SUPERGOAL RUN COMPLETE appears in the transcript with one SUPERGOAL PHASE DONE per phase, AUDIT COMPLETE printed before SUPERGOAL RUN COMPLETE, and no FAILURE HANDOFF or AUDIT HANDOFF this run
/goalnew
Configure max turns before agent stops, preventing runaway loops and controlling execution cost.
/goal budget <n Set max continuation turns
/ralphnew
A Claude Code plugin that pressure-tests a plan before any code is written: Claude writes PLAN.md, Codex adversarially reviews it from three different reviewer angles in rotation, and a Stop hook drives the draft-critique-revise cycle autonomously in one terminal window until the plan survives review or a round cap is reached.
/claudex:plan <feature> — Claude drafts PLAN.md from a one-line feature description. A Claude Code Stop hook blocks the turn and runs Codex (via `codex exec`) against the plan using a rotating reviewer persona: round 1 senior engineer, round 2 security/data-integrity, round 3+ ops/SRE. Claude reads Codex's findings and either revises PLAN.md or calls mark-done. The hook re-fires each turn, incrementing the round and rotating the persona, until Codex reports no material findings or the max-rounds cap (default 3, configurable via --rounds) is hit.
Sponsored · ConnectMyEmailLoops that read your inbox.
Email is the missing tool in your harness. ConnectMyEmail gives Claude Code and Codex a clean MCP into Gmail, Outlook, iCloud and IMAP — triage, drafts, follow-ups, on a loop.
connectmyemail.com →