Skip to content
Skills Library
Programming · Planning

plan

/plan

Design an implementation plan before writing code — where the change lands, what it will touch, what could break, and the steps in order. Use when asked to plan a feature, scope a change, or figure out how to approach an edit before making it. To assess a change that already exists (a diff, refactor, or rename), use review instead.

Repository
mimirs ↗
Licence
Apache-2.0
Last repository change
15.08.2026

Assessment and security

86/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content21 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 15.08.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Design an implementation plan before writing code — where the change lands, what it will touch, what could break, and the steps in order. Use when asked to plan a feature, scope a change, or figure out how to approach an edit before making it. To assess a change that already exists (a diff, refactor, or rename), use review instead.

Original author description

Design an implementation plan before writing code — where the change lands, what it will touch, what could break, and the steps in order. Use when asked to plan a feature, scope a change, or figure out how to approach an edit before making it. To assess a change that already exists (a diff, refactor, or rename), use review instead.

How it works

SKILL.md has no level-two headings · 14 lines, 288 words

SKILL.md preview
---
name: plan
description: Design an implementation plan before writing code — where the change lands, what it will touch, what could break, and the steps in order. Use when asked to plan a feature, scope a change, or figure out how to approach an edit before making it. To assess a change that already exists (a diff, refactor, or rename), use review instead.
---

# Plan

Goal: a concrete, ordered plan grounded in real source — and the blast radius of each proposed change *before* writing it.

1. **Understand the area** — `search "<feature/topic>"` for the relevant files, then `read_relevant "<behavior>"` to read the actual functions/sections with line ranges. Don't plan against guessed code.
2. **Where it lands** — `write_relevant "<what you're adding>"` for the best insertion point (file + anchor) for new code; `project_map(focus: <key file>)` for how the target neighborhood connects.
3. **Impact of the change** — for each symbol you intend to modify: `impact <symbol>` (transitive callers as a pruned tree + the tests to run) so the plan accounts for every caller it ripples to. Widen with `usages <symbol>` (call sites) and `dependents <file>` (file-level importers). `trace from=<a> to=<b>` to confirm two symbols actually connect before relying on the path.
4. **Prior decisions & caveats** — `search_checkpoints "<area>"` and `search_commits "<area>"` so the plan doesn't undo a deliberate choice; `get_annotations` on the files you'll touch for known bugs, constraints, or "don't refactor until X".
5. **Resolve open decisions** — before drafting, surface the choices the source doesn't settle (approach, scope, naming, tradeoffs) and ask the user. Don't guess past a fork that changes the plan; one round of focused questions beats a plan built on a wrong assumption.
6. **Draft the plan** — ordered steps, each naming the `file:line` to edit, what changes, the callers it impacts (from step 3), and the tests to run. Call out risks and remaining open questions instead of hiding them.

Finish: present the plan for review before implementing — steps in order, impact per step, tests to run, prior decisions respected, each with a `file:line` citation. Let the user review before acting.

Versions

RepositoryScoreLicence
This page · thewinci/mimirs86Apache-2.0
mlophez/polix-ai100Apache-2.0
jeremylongshore/tons-of-skills-marketplace100MIT
duronext/jig100MIT
rjmurillo/ai-agents100MIT
rjmurillo/ai-agents100MIT
rjmurillo/ai-agents100MIT
xoai/sage100MIT
JoDi-27/JoDi-SDD100MIT

Database snapshot: 13.11.2026 · package version 223085d4006a (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100write-plan
    Use when asked to write, draft or start an implementation plan for a change that already has an intent and a spec, before any code exists.
  • 100planning
    Use when starting a non-trivial feature, refactor, or multi-file change. Forces structured design thinking before writing any code - brainstorm approaches, get approval, then create a step-by-step implementation plan.
  • 90clotho-research
    Find what a change will actually touch before planning it — the existing code that must change, the prior art worth copying, and the risks that will bite. Trigger on "what would this change touch", "research this before we plan it", or an automated pre-planning step. Reports…
  • 100writing-plans
    Use when you have a spec, design doc, or requirements and need a detailed implementation plan before coding. Triggers: 'write a plan', 'create implementation plan', 'plan this out', 'break this down into steps', 'convert design to tasks', 'implementation order'. Also invoked by…
  • 100plan-work
    Break down an issue or task into concrete implementation steps with file locations, code changes, and acceptance criteria. Use when the user asks to "plan the implementation", "break down this task", "create an implementation plan", or needs a structured plan before coding.
  • 100plan-review
    Pre-flight check of an implementation plan, delegated to one fresh-context plan-reviewer subagent that reads the repo and checks the plan's assumptions, order, verification and irreversible steps against the actual code. Not a design debate — open questions come back as small…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.