Skip to main content
skill CX Codex

autoplan — Claude Code skill: plans and installation

The autoplan Claude Code skill drafts implementation plans without asking follow-up questions. It inspects the repository and maps risks to concrete plan steps.

MIT 287 installs ★ 6 updated 2026-11-10

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add prathamdby/skills --skill autoplan -a claude-code
Open on GitHub

What autoplan does

autoplan runs in Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode. It analyzes a request and its repository, then returns a plan in the conversation or at a path named by the caller. It does not edit product code.

The skill checks contracts and related files, and uses ADRs, tests, and repository notes as evidence. The plan depth follows the task: small changes get a compact response, while migrations and risky work get assumptions, a file map, ordered phases, and outcome checks. Each identified risk belongs to a plan step.

When a request lacks a grounded target or asks for implementation rather than planning, autoplan returns BLOCKED with the missing detail and a workable example. Its cold scan is bounded to at most three anchors per module, across up to 30 manifest modules.

What it helps with

  • draft an implementation plan without follow-up questions
  • split a large change into reviewable phases
  • locate relevant contracts, tests, and ADRs
  • assign risks to specific plan steps
  • decide whether a change needs a short or detailed plan

Example prompts for the agent

  • Plan a schema migration in this repository without asking me questions.
  • Break the new API work into phases and attach risks to each one.
  • Draft a contract-change plan and include checks for its expected outcomes.

How to install autoplan

1Skills CLI (Vercel)

npx skills add prathamdby/skills --skill autoplan -a claude-code

2Manually: put the files in place

~/.claude/skills/autoplan/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/autoplan/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about autoplan

How do I install autoplan in Claude Code?

Run npx skills add prathamdby/skills --skill autoplan -a claude-code. The skill file is at ~/.claude/skills/autoplan/SKILL.md.

What does autoplan do?

It examines a request and its repository, then produces an implementation plan with phases, risks, and outcome checks. It does not change product code.

Will autoplan implement a requested feature?

No. It is for planning, not product edits. For a build request, it returns BLOCKED, names the missing planning target, and gives a workable example.

Source text

SKILL.md · MIT
---
name: autoplan
description: >
  When the user wants an implementation plan written without stopping for questions.
---

# Autoplan

Analysis only. Deliver one plan in thread, or at the caller's named path.

## Options and triage

Default: current repo, standard depth, thread output. Quick/sketch uses Shape
and Risks with always-on lenses. Thorough/risky/migration uses deep, winning
over quick; a named area scopes evidence. Resolve conflicting scope narrowly
and record both readings under Assumptions; never ask.

Before evidence, `BLOCKED` if no groundable verb/object/area, a non-repo intent
has no plannable target, or building rather than planning was requested.
Name the missing piece and one workable example; emit no lenses/map/milestones
on refusal. A build request does not authorize product edits by this skill.

Trivial means one module, no contract/data/signature change, and one-sentence
behavior. Return `DIRECT` plus that sentence and three lines: shape, files,
first step; no lenses. Otherwise record `intent | scope | depth | terminal`.
Done when triage has a terminal or a grounded target.

## 1. Evidence

Check whether the requested contract already exists; harden an existing match,
not rebuild it. Locate sibling recon's installed `SKILL.md` to resolve its
anchor and shared/legacy memory rules. Read a repository-verified snapshot
whose head resolves; do not invoke a refresh merely to read it. Without usable
memory, cold-scan at most three anchors for each of at most 30 manifest modules.
Missing recon is not an evidence dependency: use that bounded scan instead.

Scan ADR trees (`docs/adr/`, `adr/`, `doc/adr/`, `docs/decisions/`) silently
when absent. Note TODOs, recent reverts, and duplication. Dirty content is an
Assumptions overlay, not proof of existing contracts. Every later claim cites
a path/test/ADR, a scoped no-match result, or an explicit missing-evidence
Assumption; cite inherited patterns. Done when material claims have provenance.

## 2. Lenses

Apply all always-on probes in `REFERENCE.md`: contracts/API, failure/rollback,
longevity/debt. For a leaf, playbook, or matcher, also apply
`references/router-contracts.md`.

Score every probe for each activated lens, turning a hit into a cited risk
owned by a plan step; close each lens pass with cite, risk → step, or no evidence.
Deep activates all. Otherwise load only triggered lenses:
- Schema/backfill, stored artifacts, toolchain: `references/data.md`.
- External consumers/stored payloads: `references/compatibility.md`.
- Auth/secrets/PII/untrusted input: `references/security.md`.
- Hot paths/cost-bearing calls: `references/cost.md`.
- Services/deployment/paging: `references/operations.md`.
State one skip line per inactive lens. Done when every active probe is scored
and each risk has an owner.

## 3. Plan

Specify decisions, changed contracts, constraints, and deviations from cited
patterns, not implementation bodies or restatements. Standard/deep includes:
Assumptions; Shape (bold sentence + pattern); Layer map (NEW/CHANGED roles);
phase sequence; file-plus-symbol grounding (prose: file + contract step);
worst-first Risks (probability × impact, or stated judgment); Milestones;
non-goals. Sketch includes only Shape and Risks.

Small work is one PR. Larger work lists every milestone in build order, and
each milestone is one reviewable vertical PR. Approval covers that whole
list, in that order. The first milestone is the thinnest end-to-end
contract/check slice. Later milestones stay in the same approval. Do not
ask which milestone to build.
Name landed symbols, expected success and relevant failure outcomes, and
assertions or observed manual results proving them. Exit zero alone is not
proof.
End the plan on its last section. End a DIRECT reply on its three lines.
End a BLOCKED reply on the missing piece and the workable example. Add no
next step, handoff, review route, or ship route in any section. A route the
caller already has stays with the caller. Name a skill or file when the work
changes it.
Done with `PLANNED` when behavior is grounded or assumed, risks are owned,
and every milestone has outcome-linked checks.

Terminals: `PLANNED`, `DIRECT`, `BLOCKED`.

© prathamdby · MIT · prathamdby/skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set19

The whole set →
gh The gh skill lets an agent inspect PRs, discussions, and CI, post replies, and handle GitHub commands that need more than a simple call. CX Codex +1 420installs cursor-agent A skill for Claude Code, Codex, and Cursor runs the local cursor-agent CLI and checks its outcome. It handles tasks involving CLI modes, sessions, and worktrees. CX Codex +1 347installs codex Runs the local Codex CLI when the agent asks. Triggers when a task requires calling Codex CLI with specific flags and no manual approvals. CX Codex +1 331installs claude-code This Claude Code skill runs the local CLI with selected options and checks the result. It also handles requests to change installation, sign-in, or connected tools. CX Codex +1 329installs upfront-design upfront-design — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI and OpenCode that runs structured design sessions before any code is written. It pauses after each of five phases until the user approves the output. CX Codex +1 321installs todoist-task Creates Todoist tasks directly from your editor. Recognises task requests, resolves project and date details, shows a preview before creating, and verifies the result in Todoist. CX Codex +1 315installs use-skill use-skill pulls a skill from a GitHub link, checks its structure and runs the steps in a temp folder. Nothing lands in your project. CX Codex +1 294installs restate restate — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that retells the agent's last reply in plain words. Kicks in when you need a catch-up or want to know exactly what decision is waiting on you. CX Codex +1 256installs

Project sponsors

Companies that keep this analytics open