autogrind-skills

Tell your agent to start working. Walk away. Come back to finished work.

AutoGrind is a skill for AI coding agents that makes them work continuously and autonomously, grinding through improvements, fixes, tests, and polish in repeating cycles until you say stop. No hand-holding. No "should I continue?" No stopping because the TODO list looks empty.

Works for any long-running workflow: code, ML, research, design, writing.

Compatible with the Agent Skills open standard; works across Claude Code, Codex, Gemini CLI, OpenCode, Cursor, Windsurf, Roocode, Cline, Trae, Kimi Code, GitHub Copilot, Goose, AmpCode, Kilo, Kiro, Factory, Hermes Agent, and any skills-compatible agent. Each mechanism is grounded in published AI/ML research; see RESEARCH.md.

English | 简体中文

Install

Paste this into any agent chat:

Please install the AutoGrind skill from https://github.com/ttttonyhe/autogrind-skills.
Clone the repo, install the autogrind/ skill to the right location for my agent environment,
and confirm it is ready to use.

Then invoke it:

/autogrind

Remember to enable unrestricted tool use so AutoGrind can run commands, read files, and commit without per-call permission prompts. For example:

claude --dangerously-skip-permissions

Without this, AutoGrind pauses on every tool call. It works, but defeats the purpose.

Universal (all agents)

All agentskills.io-compatible agents discover skills from ~/.agents/skills/. One install, all agents:

git clone https://github.com/ttttonyhe/autogrind-skills.git
cd autogrind-skills

# Symlink (live updates from this repo)
ln -sfn "$(pwd)/autogrind" ~/.agents/skills/autogrind

# Or copy for a stable install
cp -r autogrind ~/.agents/skills/autogrind

Claude Code

# Symlink (live updates from this repo)
ln -sfn "$(pwd)/autogrind" ~/.claude/skills/autogrind

# Or copy for a stable install
cp -r autogrind ~/.claude/skills/autogrind

Invoke: /autogrind or "keep working, don't stop"

Codex

cp -r autogrind ~/.agents/skills/autogrind

Codex discovers skills automatically. Enable full auto-approval in your Codex config so tool calls are not gated on confirmation.

Invoke: activate_skill autogrind or "autogrind this project"

Gemini CLI

cp -r autogrind ~/.gemini/skills/autogrind
# Or use the universal path: ~/.agents/skills/autogrind

Gemini CLI discovers skills automatically from ~/.gemini/skills/ — no GEMINI.md entry required. For local development, use gemini skills link to symlink.

Invoke: gemini "autogrind this project, don't stop until I say so"

OpenCode

cp -r autogrind ~/.agents/skills/autogrind
# Or: ~/.claude/skills/autogrind (OpenCode checks both)

OpenCode discovers skills automatically — no AGENTS.md entry required.

Invoke: opencode "autogrind this project, keep going until I say stop"

Cursor

cp -r autogrind ~/.cursor/skills/autogrind
# Or use the universal path: ~/.agents/skills/autogrind

Enable auto-run for terminal commands in Cursor settings.

Invoke: "Keep working on this project autonomously. Don't stop."

Windsurf

# Preferred path
cp -r autogrind ~/.codeium/windsurf/skills/autogrind
# Or universal path
cp -r autogrind ~/.agents/skills/autogrind

Invoke: "autogrind this project, don't stop"

Roocode

# Preferred path
cp -r autogrind ~/.roo/skills/autogrind
# Or universal path
cp -r autogrind ~/.agents/skills/autogrind

Invoke: "Keep working, don't stop"

Cline

# Preferred path
cp -r autogrind ~/.cline/skills/autogrind
# Or universal path
cp -r autogrind ~/.agents/skills/autogrind

Invoke: "autogrind this project, keep going"

Trae

# Preferred path
cp -r autogrind ~/.trae/skills/autogrind
# Or universal path
cp -r autogrind ~/.agents/skills/autogrind

Invoke: "autogrind this, don't stop" or /autogrind

Kimi Code

cp -r autogrind ~/.config/agents/skills/autogrind
# Or project-level
cp -r autogrind .kimi/skills/autogrind

Invoke: /skill:autogrind or "keep working, don't stop"

GitHub Copilot

# Preferred paths
cp -r autogrind ~/.copilot/skills/autogrind
# Or universal path
cp -r autogrind ~/.agents/skills/autogrind

Pair with a .github/copilot-instructions.md file to give Copilot project context.

Invoke: "autogrind mode — keep working autonomously" or /autogrind

Goose

cp -r autogrind ~/.agents/skills/autogrind

Invoke: "autogrind this project, keep going"

AmpCode

# Preferred path
cp -r autogrind ~/.config/agents/skills/autogrind
# Or universal path
cp -r autogrind ~/.agents/skills/autogrind

Invoke: "autogrind this, don't stop"

Kilo / Kiro / Factory

cp -r autogrind ~/.agents/skills/autogrind

All support the agentskills.io universal path. Install once, invoke directly.

Invoke: "Keep working on this project. Don't stop." or "autogrind"

Hermes Agent (NousResearch)

cp -r autogrind ~/.agents/skills/autogrind

Invoke: "autogrind this, keep going"

Update

Paste this into any agent chat:

Please update the AutoGrind skill to the latest version from https://github.com/ttttonyhe/autogrind-skills.

# If installed as symlink — no action needed, repo changes are live immediately.

# If installed as copy, re-run the install command:
cp -r autogrind ~/.claude/skills/autogrind    # Claude Code
cp -r autogrind ~/.agents/skills/autogrind    # Universal / Codex / Gemini / OpenCode / Cursor

The Grind Cycle

flowchart TD
    INIT["INIT (once)\nDetect guidance files\nExtract goals and conventions"]
    OV["1. OVERVIEW\nAssess project state"]
    UN["2. UNDERSTAND\nReview relevant work and history"]
    PL["3. PLAN\nPrioritized tasks + frontier scan"]
    WK["4. WORK\nExecute, validate, persist"]
    RF["5. REFLECT\nGrounded signals + heuristics"]
    PA["PAUSE 60s\nAnnounce, wait, continue"]
    ST{"Explicit stop\nsignal?"}
    STOP(["STOP"])
    NEVER["NEVER stop\non your own"]

    INIT --> OV --> UN --> PL --> WK --> RF --> PA --> ST
    ST -->|yes| STOP
    ST -->|no, always| OV
    ST -.->|tempted to stop| NEVER

Every Reflect phase: checks verifiable signals first (test results, metrics, build status), evaluates core deliverable progress, scans quality dimensions (coverage, error handling, docs, performance, UX, observability, security), detects stuck loops and shifts focus, and extracts a transferable heuristic for the next cycle. There is always a weakest dimension.

After each cycle, AutoGrind pauses 60 seconds so you can interrupt. If you do nothing, it continues automatically.

FAQ

When does it stop? What if my project is already complete?

AutoGrind stops only when you explicitly tell it to: "stop", "halt", "pause", "that's enough", or any clear termination request. It never stops on its own.

If your project feels done, AutoGrind will find the next improvement: coverage gaps, missing documentation, performance wins, edge cases, polish. The Reflect phase evaluates against a checklist of quality dimensions and always surfaces something. Say "stop" when you are satisfied.

Will it run destructive commands? Will I wake up to a broken system?

AutoGrind prioritizes reversible, tracked changes. Every code change gets committed to git, so you have a full undo trail. It does not intentionally run destructive operations (rm -rf, force push, DROP TABLE) as part of its workflow.

That said, AutoGrind runs code, edits files, and commits changes autonomously. Recommended safeguards:

• Start from a clean git working tree so all changes are tracked and easy to review
• When you return, run git log before deploying anything
• For sensitive environments, use your agent's permission controls to restrict which commands it can run

Will context compaction break AutoGrind?

No. Each cycle begins with an Overview phase that re-reads project state from scratch: git history, test output, file structure, open issues. AutoGrind does not depend on remembering previous cycles. Long sessions with multiple context compactions work fine.

Use Cases

Go to bed. Wake up to finished work.

You:   autogrind this, i'm going to bed
Agent: [starts grinding]
       cycle 1 - fixed broken import, added 12 tests
       cycle 2 - documented all exported functions
       cycle 3 - reduced DB query count by 40%
       cycle 4 - added input validation, edge case tests
       ...
You:   [8 hours later] stop

ML / data science - point it at a training script. It runs experiments, inspects metrics, adjusts hyperparameters, re-runs, and iterates. Come back to a full experiment trail and an improved model.

Academic research - grind through a literature review, fill methodology gaps, expand weak sections, cross-check citations. Each cycle improves the manuscript.

Codebase cleanup - point it at a messy repo. It fixes linting, improves coverage, fills doc gaps, and refactors the worst offenders, in priority order, with meaningful commits.

Design iteration - work through a revision backlog: consistency checks, accessibility improvements, copy edits, spacing fixes. Any workflow where "keep improving until told to stop" is the right mode.

What Gets Committed

AutoGrind commits after each logical change, with a meaningful message. When you return, git log tells the full story.

$ git log --oneline
f3a1b2c Reduce N+1 queries in UserRepository.findByOrg()
e8