agentleFS
khairoldkhairold/claude-skills/skills/autopilot-execute/SKILL.md

autopilot-execute

Skill0 starsChanged 7 months agoMITView on GitHub

Unattended execution of the next plan item(s). Reads project context and .plan/ files, executes work autonomously without human confirmation, verifies the build, updates all plan files, and exits. Designed to be invoked repeatedly in successive sessions.

The file

Show its rules and text

We split this skill into the rules it gives an agent

40 rules. About 0 are common, 31 are distinctive, and 9 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈31

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 9

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Do not ask questions. Do not wait for confirmation.

    line 10
  2. Very specific:

    Read autopilot.config in the project root.

    line 14
  3. Very specific:

    If autopilot.config does not exist, detect the project's build system:

    line 18
  4. Very specific:

    If bun.lockb or bun.lock exists → bun run typecheck

    line 19
  5. Very specific:

    If pnpm-lock.yaml exists → pnpm run typecheck

    line 20
  6. Very specific:

    If no typecheck script in package.json, try npm run build

    line 23
  7. Distinctive:

    Read these files in this order:

    line 27
  8. Distinctive:

    If CLAUDE.md references additional files to read (AGENTS.md, CONVENTIONS.md, etc.), read those too — but be fast.

    line 34
  9. Distinctive:

    Look at the next unchecked item in the current phase.

    line 44
  10. Distinctive:

    If the item is small (create a helper function, add a config value, write a type definition) → combine it with the next 1-2 unchecked items …

    line 47
  11. Distinctive:

    If the item is medium (build a module, implement a feature, create a component) → do just that item

    line 48
  12. Distinctive:

    If the item is large (complex multi-file feature, integration work) → do just that item, potentially noting sub-progress

    line 49
  13. Distinctive:

    If it's a verification item (e.g., "verify all endpoints work", "run full test suite") → run the checks, report results

    line 50
  14. Distinctive:

    If it's a CREATE TASKS item (meta-task) → read the data source, generate the plan items, insert them, then EXIT immediately

    line 51
  15. Distinctive:

    NEVER pick items from the next phase.

    line 59
  16. Distinctive:

    If this is the LAST item in the phase, complete it, verify exit criteria from PLAN.md, then update the plan header.

    line 60
  17. Distinctive:

    Do the work. Be thorough.

    line 64
  18. Distinctive:

    Read CLAUDE.md for project conventions, key file locations, and commands

    line 67
  19. Distinctive:

    Check MEMORY.md for architectural patterns and decisions

    line 68
  20. Distinctive:

    Check CONVENTIONS.md for build rules with ✅/❌ examples

    line 69
  21. Distinctive:

    Always read existing source files before modifying — understand full context

    line 70
  22. Distinctive:

    Follow patterns established in previous sessions (documented in MEMORY.md)

    line 71
  23. Distinctive:

    When building something analogous to a reference repo pattern, read the reference first

    line 72
  24. Distinctive:

    If you discover something unexpected, make a judgment call and log it in DRIFT.md

    line 76
  25. Distinctive:

    If a file you need doesn't exist, note it and skip gracefully

    line 77
  26. Distinctive:

    Follow the architectural patterns from MEMORY.md and CONVENTIONS.md

    line 78
  27. Very specific:

    Run the build command from autopilot.config to confirm nothing is broken:

    line 87
  28. Distinctive:

    Read the error output carefully

    line 96
  29. Distinctive:

    Run the build again after each fix

    line 98
  30. Distinctive:

    If still failing after 2 attempts:

    line 99
  31. Distinctive:

    Leave the item unchecked in PLAN.md

    line 100
  32. Very specific:

    Add a note to the item: - [ ] N.X — {Description} ⚠️ BUILD FAILED: {brief error}

    line 101
  33. Distinctive:

    Update MEMORY.md with the gotcha

    line 103
  34. Very specific:

    Check off completed items: - [ ] → - [x]

    line 111
  35. Very specific:

    If phase is complete: update Current Phase: to next phase, Status: to note completion

    line 114
  36. Distinctive:

    If this was the last item in the phase, verify exit criteria and note result

    line 115
  37. Distinctive:

    Add any new decisions to the Key Decisions table (increment the # counter)

    line 118
  38. Distinctive:

    Add any new gotchas to Gotchas & Warnings

    line 119
  39. Distinctive:

    Update Architecture Notes or Technical Context if anything changed

    line 120
  40. Distinctive:

    If anything deviated from the plan or previous patterns, log it

    line 123

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Autopilot Execute

You are running unattended. No human is present. Be fully autonomous. Do not ask questions. Do not wait for confirmation. Make decisions and log them.

Step 0 — Read Project Config

Read autopilot.config in the project root. It defines:

  • BUILD_CMD — the command to verify the project builds (may chain multiple checks)
  • PROJECT_DIR — the directory containing the project source (. for monorepos)

If autopilot.config does not exist, detect the project's build system:

  • If bun.lockb or bun.lock exists → bun run typecheck
  • If pnpm-lock.yaml exists → pnpm run typecheck
  • If yarn.lock exists → yarn typecheck
  • Otherwise look for package.json → npm run typecheck
  • If no typecheck script in package.json, try npm run build

Step 1 — Orient (mandatory, fast)

Read these files in this order:

  1. CLAUDE.md — Project identity, current state, commands, conventions
  2. .plan/PLAN.md — Find current phase and next uncompleted item
  3. .plan/MEMORY.md — Absorb all shared context, decisions, gotchas
  4. .plan/DRIFT.md — Check for spec changes

If CLAUDE.md references additional files to read (AGENTS.md, CONVENTIONS.md, etc.), read those too — but be fast. Orientation should take seconds, not minutes.

Then print exactly one status line:

📍 Phase {N} — {Phase Name} | 📋 Next: {N.X} — {Description} | 📝 {count} items left in phase

Step 2 — Scope

Look at the next unchecked item in the current phase.

Sizing judgment:

  • If the item is small (create a helper function, add a config value, write a type definition) → combine it with the next 1-2 unchecked items in the same phase
  • If the item is medium (build a module, implement a feature, create a component) → do just that item
  • If the item is large (complex multi-file feature, integration work) → do just that item, potentially noting sub-progress
  • If it's a verification item (e.g., "verify all endpoints work", "run full test suite") → run the checks, report results
  • If it's a CREATE TASKS item (meta-task) → read the data source, generate the plan items, insert them, then EXIT immediately

Announce your scope:

🎯 This iteration: {N.X} — {Description} [and {N.Y} if combining]

Rules:

  • NEVER pick items from the next phase. If all items in the current phase are checked, update the PLAN.md header to mark the phase complete and EXIT immediately. The next session handles phase boundaries.
  • If this is the LAST item in the phase, complete it, verify exit criteria from PLAN.md, then update the plan header.

Step 3 — Execute

Do the work. Be thorough.

Reference material:

  • Read CLAUDE.md for project conventions, key file locations, and commands
  • Check MEMORY.md for architectural patterns and decisions
  • Check CONVENTIONS.md for build rules with ✅/❌ examples
  • Always read existing source files before modifying — understand full context
  • Follow patterns established in previous sessions (documented in MEMORY.md)
  • When building something analogous to a reference repo pattern, read the reference first

While executing:

  • Complete each item fully before moving to the next
  • If you discover something unexpected, make a judgment call and log it in DRIFT.md
  • If a file you need doesn't exist, note it and skip gracefully
  • Follow the architectural patterns from MEMORY.md and CONVENTIONS.md

After each item:

✅ {N.X} — {Description} — Done

Step 4 — Verify

Run the build command from autopilot.config to confirm nothing is broken:

# Execute BUILD_CMD from autopilot.config

If build succeeds: Proceed to Step 5.

If build fails:

  • Read the error output carefully
  • Attempt to fix the issue (you have 2 fix attempts)
  • Run the build again after each fix
  • If still failing after 2 attempts:
    • Leave the item unchecked in PLAN.md
    • Add a note to the item: - [ ] N.X — {Description} ⚠️ BUILD FAILED: {brief error}
    • Log the failure details in SESSION-LOG.md
    • Update MEMORY.md with the gotcha
    • EXIT. The next session will detect you're stuck.

Step 5 — Close (mandatory, NEVER skip)

Even if something went wrong, you MUST update the plan files before exiting.

Update .plan/PLAN.md:

  • Check off completed items: - [ ] → - [x]
  • Update header:
    • Last Session: → increment session number and set today's date
    • If phase is complete: update Current Phase: to next phase, Status: to note completion
  • If this was the last item in the phase, verify exit criteria and note result

Update .plan/MEMORY.md:

  • Add any new decisions to the Key Decisions table (increment the # counter)
  • Add any new gotchas to Gotchas & Warnings
  • Update Architecture Notes or Technical Context if anything changed

Update .plan/DRIFT.md:

  • If anything deviated from the plan or previous patterns, log it

Append to .plan/SESSION-LOG.md:

## Session {N} — {Item Description} ({date})

**What happened:**
- {Brief summary of work done}

**Items completed:**
- [x] {N.X} — {Description}

**Issues encountered:**
- {Any blockers, surprises, or decisions made — or "None"}

**Handoff to next session:**
- Next: {N.Y} — {Next unchecked item description}
- {Any critical context for the next iteration}

---

Update .agents/TENSIONS.md:

  • Append any friction noticed during execution (format: - {date}: [{area}] {observation})

Hard Rules

  1. NEVER skip Step 1 or Step 5 — The plan files are the shared brain. Corrupt them and everything breaks.
  2. NEVER cross phase boundaries — If you finish the last item in a phase, mark the phase complete and EXIT. Do not start the next phase.
  3. NEVER ask questions — You are unattended. Make the best decision you can. Log it in MEMORY.md or DRIFT.md.
  4. ALWAYS verify the build — The BUILD_CMD from autopilot.config must pass before you update plan files with checked items.
  5. EXIT cleanly — After Step 5, your job is done. The next session will re-invoke you if there's more work.
  6. Be conservative with scope — It's better to complete 1 item cleanly than attempt 3 and leave a mess. The next session will continue.
  7. Log everything — Decisions in MEMORY.md, deviations in DRIFT.md, friction in TENSIONS.md. The next iteration has zero memory of this one.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.