grinding-until-pass

name	grinding-until-pass
description	Keep iterating on code changes until the tests pass, the build succeeds, or linting is clean. Runs in a tight loop of fix → run → check → repeat. Use when you want the agent to autonomously grind through test failures or build errors.

On-demand loading: Read this skill only when the task clearly matches the description above or trigger phrases below. Do not load for unrelated work.

Grind Until Pass

Use this skill when you want the agent to keep working autonomously until a specific goal is met — all tests pass, the build succeeds, or linting is clean. Instead of stopping after one attempt, the agent loops until done.

Steps

1. Define the goal command — the command whose exit code determines success:

• Tests: npm test or npx vitest run
• Build: npm run build
• Lint: npm run lint
• Type-check: npx tsc --noEmit
• All of the above: npm run lint && npx tsc --noEmit && npm test && npm run build

2. Run the command — execute it and capture the output.

3. If it fails — analyze and fix:

• Read the error output carefully.
• Identify the root cause: failing test assertion, type error, lint violation, import error, etc.
• Make the minimal fix. Don't refactor — just fix the error.
• Go back to step 2.

4. If it passes — stop and report:

• Report what was fixed and how many iterations it took.
• Summarize the changes made.

Rules for the Loop

• Maximum 10 iterations — if after 10 attempts the command still fails, stop and report what's blocking progress. Something fundamental is wrong and needs human input.
• Fix one thing at a time — don't try to fix all errors at once. Fix the first error, re-run, and see if the fix resolves downstream errors too.
• Don't delete tests — if a test is failing, fix the code to make it pass. Don't modify the test unless the test itself is clearly wrong (testing old behavior that was intentionally changed).
• Don't suppress errors — don't add @ts-ignore, eslint-disable, or any types to silence errors. Fix the actual problem.
• Track progress — if the number of errors is increasing instead of decreasing, stop and reassess the approach.

When to use

• After a large refactor that broke multiple tests
• After upgrading a dependency that introduced type errors
• After merging a branch with conflicts that need resolution
• When you want to "just make it green" and trust the agent to grind through it

Advanced: Cursor Hooks Integration

You can automate this with a Cursor hook in .cursor/hooks.json that triggers after the agent's turn ends, checks if tests pass, and sends a follow-up message if they don't:

{
  "hooks": [
    {
      "event": "stop",
      "command": "bash .cursor/scripts/check-tests.sh",
      "description": "Re-run tests after agent stops and send follow-up if failing"
    }
  ]
}

The script checks the exit code and returns a followup_message if tests are still failing.

Notes

• This works best with fast test suites. If your tests take 5+ minutes, the loop will be slow.
• Use --bail or --fail-fast flags to stop at the first failure for faster iteration.
• The agent will be thorough but not creative — if the fix requires a design change, it'll need human guidance.

Related skills

• loop-on-ci: same iterate-until-green pattern but driven by PR checks (gh pr checks); prefer it when the goal is a green PR rather than a local command
• gh-fix-ci: diagnose failing GitHub Actions checks and plan the fix with user approval; prefer it when the failure only shows up in CI