Reusable prompts and step-by-step workflows that let coding agents self-pace through a task until it's done.
Run the production build, fix compile and bundling errors, and loop until the build succeeds.
Run automated accessibility checks on changed routes, fix violations, and repeat until the audit is clean.
Add focused tests until coverage meets your threshold (e.g. 80%), without changing production behavior unnecessarily.
Poll CI on an interval, investigate failures when checks go red, and push fixes until green.
Every 15 minutes, inspect open PRs with a watch label: nudge reviewers, fix CI, rebase if behind main.
Run failing tests repeatedly, classify each failure as flaky or real, and fix only confirmed regressions.
Run the formatter, fix any remaining style issues, and loop until the codebase formats cleanly with no diffs.
Fresh-context loop: pick one incomplete story from prd.json, implement it, run backpressure checks, commit, and update progress before the next iteration.
After code changes, find affected docs and update README, API references, and inline comments to match.
Hook that runs tests before git commit commands to block commits when the suite is red.
After implementation, run a cleanup pass: remove debug code, tighten naming, delete dead branches, and align with project conventions.
On an interval, hit health and smoke endpoints after a deploy until all checks return healthy responses.
When a check fails twice the same way, append a guardrail sign to .ralph/guardrails.md so the next iteration avoids repeating it.
Poll open PRs labeled codex-watch every 15 minutes, review activity, and flag regressions or stale threads.
Test-first loop: write a failing test, implement the minimum code to pass, refactor, and repeat.
Keep openapi.yaml valid and in sync with route handlers — lint the spec and fix drift each pass.
Fix high/critical npm audit findings one at a time with test verification — not a blind npm audit fix --force.
Find and remove dead exports, unused files, and orphan dependencies — loop until knip reports clean.
Implement on a branch, run tests, push, open a PR, wait for CI, and loop until checks pass and the PR is ready to merge.
When implementation claims done, a separate verifier pass runs build, lint, and tests with no access to the implementer's rationale.
After shipping a feature, loop until CHANGELOG.md has a user-facing entry and conventional commits are reflected.
Run database migrations, fix schema issues, and loop until migrations apply cleanly in dev.
Loop until API responses match the OpenAPI or JSON Schema contract — catch drift between docs and implementation.
On each failed repro attempt, write a short reflection to disk, then retry with that memory — avoids repeating the same wrong fix.
Fetch the latest failed CI run, reproduce the failure locally, fix it, and repeat until checks pass.
Hook that runs smoke tests after git merge or rebase to catch integration regressions immediately.
Run lint and typecheck, fix reported issues, and loop until the codebase is clean.
Run a fixed smoke checklist against staging after deploy: auth, core flows, and error budgets.
Hook-based loop that runs related tests after file edits to catch regressions early.
Weekly npm audit scan, triage vulnerabilities by severity, and propose or apply safe patches.
Common questions about reusable Loops for AI coding agents
A loop is a reusable workflow for AI coding agents built around four parts: a goal, a check command that objectively verifies progress, an exit condition, and a max-iteration limit. Paste the kickoff prompt into your agent and it self-paces through the task, re-running the check command after each pass until the exit condition is met.
A normal prompt is one instruction for one turn. A loop is the system around repeated turns — it tells the agent how to verify its own work and when to stop, so it can keep going without you re-prompting it after every attempt. This practice is known as loop engineering.
Most loops on this page are agent-agnostic — the kickoff prompt is plain text you can paste into Claude Code, Cursor, Codex, or any other coding agent. Each loop's page lists which agents it was specifically built and tested for.
Use a loop when a task needs several revision passes and has an objective acceptance check, such as fixing tests, resolving CI failures, reviewing code, verifying a deployment, or completing a large refactor. One-off questions and tasks without a clear definition of done usually do not need a loop.
Choose a stable, repeatable check with a meaningful exit code, such as tests, type checking, linting, or a deployment health check. Define an observable completion state and set a maximum iteration count so the AI agent cannot retry forever.
A loop repeatedly executes prompts and commands, so restrict file, network, secret, and deployment access; run risky work in an isolated branch or sandbox; and keep iteration limits and human review. Never let an unreviewed loop run destructive commands.
