Loop

A Ralph-style loop that turns open GitHub issues into pull requests, one task per iteration, until none remain.

Test-first loop: write a failing test, implement the minimum code to pass, refactor, and repeat.

Green tests are not a running app — build the production image, boot it against a fresh throwaway database, probe the real routes and contracts, fix, and re-boot until everything answers.

Run the production build, fix compile and bundling errors, and loop until the build succeeds.

After shipping a feature, loop until CHANGELOG.md has a user-facing entry and conventional commits are reflected.

Write the success criteria and load-bearing assumptions first, complete exactly one step per pass while restating done / verified / left, and loop until every criterion is checked off and backed by evidence.

Align new code to the codebase's own idioms — sample its neighbors, fix one mismatch per pass, and when two patterns conflict pick the more recent or better-tested one rather than averaging them.

Add focused tests until coverage meets your threshold (e.g. 80%), without changing production behavior unnecessarily.

After implementation, run a cleanup pass: remove debug code, tighten naming, delete dead branches, and align with project conventions.

Collapse a menu of options into one committed recommendation — research each candidate with real evidence instead of priors, score against explicit criteria, and don't stop until a single pick stands with a named runner-up.

On an interval, hit health and smoke endpoints after a deploy until all checks return healthy responses.

Treat every operational claim in your docs and runbooks as a hypothesis — verify each against the live system, fix what drifted, and loop until no claim fails verification.

Extract a shared unit only where the same logic appears three or more times — and inline back any abstraction used only once or twice.

Fetch the latest failed CI run, reproduce the failure locally, fix it, and repeat until checks pass.

Run the formatter, fix any remaining style issues, and loop until the codebase formats cleanly with no diffs.

Audit a doc, PR description, or answer for unsourced assertions and replace each hedge with a cited artifact — file:line, command output, or URL — until nothing rests on inference.

When implementation claims done, a separate verifier pass runs build, lint, and tests with no access to the implementer's rationale.

Mutate your own production code on purpose, prove a test fails for each change, and loop until no surviving mutant slips past the suite.

Before a large batch job, surface the few decisions only the owner can make, lock them in one up-front interview, then run the whole batch unattended — looping on blockers, not on questions.

Run lint and typecheck, fix reported issues, and loop until the codebase is clean.

After merging, loop until production actually reflects the merge — pipeline green, the new commit serving, fresh routes answering, and schema plus data applied.

Run database migrations, fix schema issues, and loop until migrations apply cleanly in dev.

A markdown-and-bash protocol that turns a well-scoped repo into a supervised multi-agent coding loop where a Beacon ranks the next work, you approve it, and path-owning agents build in isolated git worktrees.

Review your own diff like a senior reviewer, fix issues, and repeat for three passes before opening the PR.

Repeatedly relaunch a fresh coding-agent session against a prompt until the implementation plan is complete.

Before editing a symbol, map every caller, re-export, test, and shared util it touches — iterate until the blast radius is fully known, then write.

Attack your own just-built feature's trust assumptions — spoofable identifiers, client-settable fields, lookalike handles, reclamation attacks — fix each break and re-attack until every attack fails.

After every schema edit, regenerate migrations and prove there is no drift — loop until a fresh generate produces no new files and leaves the working tree clean.

After significant work, distill the non-obvious lessons — gotchas, environment quirks, corrections you received — into durable notes, looping until a fresh review pass surfaces nothing unrecorded.

Implement on a branch, run tests, push, open a PR, and loop until checks pass and the PR is ready to merge.

Hunt down swallowed errors, empty catch blocks, ignored return codes, silent fallbacks, and skipped tests, then make each one fail loud or carry an explicit comment justifying the suppression.

Implement from a written spec.md checklist — each iteration completes one unchecked requirement with verification.

When your sync pipeline only upserts, removals never propagate — loop until the live store's rows exactly match the curated source files, pruning orphans deliberately.

Shrink an over-broad diff back to the minimum that satisfies the goal — every changed line load-bearing, no drive-by edits — re-running tests after each cut.

Run your test suite, fix the smallest root cause on failure, and repeat until every test passes.

For every candidate item in a catalog or dataset, independently re-verify the claim and mechanically confirm its source URL resolves — include it with evidence or drop it with a written reason.

Run lint, typecheck, tests, and build as one chained gauntlet under a 'a warning FAILS' bar, and loop until the whole chain exits clean with the word 'warning' nowhere in its output.