grinding-until-pass

Original：🇺🇸 English

Translated

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.

3installs

Sourcespencerpauly/awesome-cursor-skills

Added on2026-05-16

NPX Install

npx skill4agent add spencerpauly/awesome-cursor-skills grinding-until-pass

SKILL.md Content

View Translation Comparison →

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

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

Run the command — execute it and capture the output.
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.
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 This

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:

json

{
  "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.