A curated collection of AI-powered development loops for automating software development tasks.

Loop is an automated workflow instruction set for AI programming assistants (like Claude Code, Cursor). It enables AI to autonomously complete development tasks through a "execute → check → fix → repeat" closed-loop pattern until a preset goal is achieved.

Use Loops when you need:

• Continuous Iteration - Tasks that require repeated check, fix, re-check cycles
• Quality Gates - Keep code, builds, and tests in a healthy state
• Workflow Automation - Reduce repetitive manual operations
• CI/CD Integration - Automatically fix failing CI builds

✅ Run tests until all pass
✅ Fix CI failures and verify
✅ TDD development workflow
✅ Code review and refactoring
✅ Dependency management and security audits
✅ API contract validation
✅ Deployment verification
❌ Simple one-time Q&A
❌ Creative design work

Visit https://loops.elorm.xyz/loops to browse, search, and install the Loops you need.

/loop <loop-name>

For example:

/loop test-until-green
/loop fix-ci-until-green
/loop pr-self-review

Paste Loop instructions into your preferred AI programming assistant and follow its check commands.

Goal: All tests pass

npm test

Run tests, fix the smallest root cause, repeat until all tests pass.

# Usage
/loop test-until-green

Goal: E2E test suite passes

npm run test:e2e

Run E2E tests, fix the first failing spec, repeat until all pass.

# Usage
/loop e2e-until-green

Goal: Classify failing tests as flaky or real, fix only confirmed regressions

npm test -- --testPathPattern=<failing-suite>

Run failing test suite multiple times, classify each failure, fix real ones, document flaky behavior.

# Usage
/loop flaky-test-triage

Goal: Visual regression tests pass with intentional UI changes only

npx playwright test --grep @visual

Run visual tests, fix unintended UI diffs; update baselines only for deliberate design changes.

# Usage
/loop visual-regression-until-match

Goal: Coverage meets target threshold (default 80%) with all tests passing

npm test -- --coverage

Run coverage, add focused tests for biggest uncovered gaps, repeat until threshold is met.

# Usage
/loop coverage-until-threshold

Goal: Staging smoke checklist passes

npm run smoke:staging

Run staging smoke checklist, fix the first failing item, repeat until passing.

# Usage
/loop staging-smoke-test

Goal: After each batch of file edits, related tests must pass before continuing

npm test -- --findRelatedTests <edited files>

After edits, run related tests. If they fail, fix before making more changes.

# Usage
/loop post-edit-test-guard

Goal: PR is open with all CI checks passing

gh pr checks

Implement change, test locally, push, open PR, fix CI until all pass.

# Usage
/loop ship-pr-until-green

Goal: Latest CI run on current branch passes

gh run list --branch $(git branch --show-current) --limit 1 --json conclusion -q '.[0].conclusion'

Find latest failed CI run, read logs, reproduce locally, fix root cause, push, verify.

# Usage
/loop fix-ci-until-green

Goal: Latest CI run on current branch is green

gh run list --branch $(git branch --show-current) --limit 1

Check CI status, if failed read logs, fix root cause, verify locally, push if needed.

# Usage
/loop ci-failure-watcher

Goal: Production build succeeds

npm run build

Run build, if it fails fix the first error, repeat until green.

# Usage
/loop build-until-green

Goal: Block git commits when tests are failing

npm test

Before any git commit, run tests, fix failures before committing.

# Usage
/loop pre-commit-guard

Goal: Three clean self-review passes on the current diff

git diff main...HEAD

Review the diff like a senior reviewer, fix findings, then re-review.

# Usage
/loop pr-self-review

Goal: PRs labeled codex-watch are healthy (CI green, rebased, not stale)

gh pr list --label "codex-watch"

List watched PRs, fix CI once, rebase if behind, comment if stale. Escalate repeated failures.

# Usage
/loop pr-babysitter

Goal: Keep codex-watch PRs healthy and unblocked

gh pr list --label codex-watch --json number,title,state,statusCheckRollup

List codex-watch PRs, check CI and reviews, report or fix trivial blockers.

# Usage
/loop pr-watch-loop

Goal: Every requirement in spec.md is implemented and checked off

npm test

Read spec.md, implement the first unchecked item, verify it, mark [x], stop this iteration.

# Usage
/loop spec-first-ship

Goal: Lint and typecheck are clean

npm run lint && npx tsc --noEmit

Run lint and typecheck, fix reported issues with minimal diffs, repeat.

# Usage
/loop lint-typecheck-fix

Goal: Formatter runs cleanly with no remaining diff

npm run format

Run formatter, fix any issues it cannot auto-fix, repeat.

# Usage
/loop format-until-clean

Goal: Recent changes are clean, minimal, and convention-aligned

npm run lint && npm test

Review diff for debug code, dead branches, naming issues, fix with minimal diffs.

# Usage
/loop de-sloppify-pass

Goal: Knip reports no unused code or dependencies

npx knip

Run knip, remove dead exports and unused deps with minimal diffs, verify tests still pass.

# Usage
/loop knip-until-clean

Goal: API implementation matches the published contract

npm run test:contract

Run contract tests, fix each schema/response mismatch with minimal diffs, re-run.

# Usage
/loop api-contract-until-match

Goal: openapi.yaml lints clean and matches implemented routes

npx @redocly/cli lint openapi.yaml

Lint openapi.yaml, fix spec errors and handler drift until lint passes.

# Usage
/loop openapi-sync-until-valid

Goal: Critical outdated deps upgraded with green tests

npm outdated && npm test && npm run build

Pick one outdated package, upgrade it, fix breakages, commit, stop. One package per iteration.

# Usage
/loop dependency-upgrade-one-by-one

Goal: All database migrations apply cleanly

npx prisma migrate status

Run migrations, fix schema or SQL errors, repeat until status is clean.

# Usage
/loop migration-until-applied

Goal: Deliver weekly dependency audit summary

npm outdated || true

Run npm outdated, categorize updates, propose safe upgrade plan.

# Usage
/loop dependency-audit-weekly

Goal: No high or critical npm audit vulnerabilities

npm audit --audit-level=high && npm test

Pick one high/critical advisory, apply safest fix, run tests, repeat.

# Usage
/loop npm-audit-fix-loop

Goal: Deliver weekly npm audit summary with remediation plan

npm audit --json

Run npm audit, triage by severity, propose safe remediation steps.

# Usage
/loop security-audit-weekly

Goal: Implement target behavior test-first with green suite

npm test

Write a failing test for the next behavior, implement minimum code to pass, refactor, repeat.

# Usage
/loop autoloop-tdd

Goal: CHANGELOG.md has accurate [Unreleased] entries

git log -5 --oneline

Review recent commits, write Keep-a-Changelog entries for user-visible changes, verify completeness.

# Usage
/loop changelog-sync-after-ship

Goal: Prove the root cause with a minimal repro script

node scripts/investigate.mjs

Write a tiny throwaway script that reproduces the issue, run it, iterate on output.

# Usage
/loop investigation-script-loop

Goal: Every story in .ralph/prd.json has passes: true

npm test && npm run lint && npm run build

Read .ralph/prd.json and .ralph/progress.md, pick one incomplete story, implement it, run backpressure checks, commit, update prd.json and progress.md, stop this iteration.

# Usage
/loop ralph-story-executor

Goal: The failing test or repro passes

npm test -- --testNamePattern=<failing-test>

Reproduce the bug. If it fails, append a reflection to .loops/reflexion.md before trying a new fix.

# Usage
/loop reflexion-debug-loop

Goal: Documentation matches the current code changes

git diff main...HEAD --name-only

Review the diff, find stale docs, update them, verify accuracy.

# Usage
/loop docs-sync-after-edits

Goal: Client bundle stays under the size-limit budget

npm run build && npm run size-limit

Build and measure bundle size, if over budget lazy-load or trim deps until size-limit passes.

# Usage
/loop bundle-size-budget

Goal: Zero serious accessibility violations on changed UI

npm run test:a11y

Run a11y audit on changed routes, fix each violation, prioritize keyboard and screen reader issues.

# Usage
/loop a11y-audit-until-clean

Goal: Branch is rebased on main with no conflicts and tests pass

npm test

Rebase on main, resolve conflicts one file at a time, run tests, continue.

# Usage
/loop merge-conflict-resolver

Goal: Smoke tests pass immediately after every merge or rebase

npm run test:smoke

After a merge, run smoke tests, fix regressions before continuing other work.

# Usage
/loop post-merge-regression-guard

Goal: All post-deploy health and smoke endpoints return success

curl -fsS <your-health-url>

Hit health/smoke URLs, if any fail inspect deploy logs, fix or escalate.

# Usage
/loop deploy-verification-loop

Goal: Build, lint, and tests pass under independent verification

npm run build && npm run lint && npm test

Run build, lint, and tests as a verifier. Trust only command output, not prior claims.

# Usage
/loop independent-verifier-pass

Goal: Tests and lint pass without repeating prior failure patterns

npm test && npm run lint

Read .ralph/guardrails.md, run checks, if a failure repeats add a sign before fixing.

# Usage
/loop guardrails-learning-loop

A Loop consists of:

Name
├── Goal - The final state the Loop aims to achieve
├── Check Command - Command to verify if the goal is met
├── Max Iterations - Maximum iterations to prevent infinite loops
├── Exit Condition - When to stop successfully
├── Steps - Specific operations for each iteration
└── Recommended Agents - Suitable AI programming assistants

1. Define the Goal - What do you want to automate?
2. Design the Check Command - How to verify goal achievement?
3. Write the Steps - How should the AI iterate?
4. Set Exit Conditions - When to stop?
5. Test Your Loop - Verify in real scenarios

### My Custom Loop

**Goal:** Code formatting is clean

**Check Command:**
\`\`\`bash
npm run format && git diff --exit-code
\`\`\`

**Exit Condition:** git diff is empty (no formatting changes needed)

**Steps:**
Step 1: Run the formatter command.
Step 2: Check git diff, if there are changes commit them.
Step 3: Repeat until no changes.

**Recommended Agents:** Claude Code, Cursor

License: MIT Maintainer: Agents Version: 1.0.0