Skip to content
Skills Library
Management & product · Planning

implementation-planning

/implementation-planning

Use this skill when the user asks to \"plan this feature\", \"write an implementation plan\", \"design before coding\", \"think through the approach\", \"review this plan\", or before any multi-file change, architectural decision, experiment with a go/no-go outcome, or strategic pivot. Produces a verifiable plan with pre-registered decision gates and an explicit list of open judgment calls.

Licence
MIT
Last repository change
09.11.2026

Assessment and security

100/ 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.
Content35 / 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
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

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

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use this skill when the user asks to \"plan this feature\", \"write an implementation plan\", \"design before coding\", \"think through the approach\", \"review this plan\", or before any multi-file change, architectural decision, experiment with a go/no-go outcome, or strategic pivot. Produces a verifiable plan with pre-registered decision gates and an explicit list of open judgment calls.

Triggers from the description

plan this feature\write an implementation plan\design before coding\think through the approach\review this plan\
Original author description

Use this skill when the user asks to \"plan this feature\", \"write an implementation plan\", \"design before coding\", \"think through the approach\", \"review this plan\", or before any multi-file change, architectural decision, experiment with a go/no-go outcome, or strategic pivot. Produces a verifiable plan with pre-registered decision gates and an explicit list of open judgment calls.

How it works

  1. Model assignment (lab addendum)
  2. Pick the register (by stakes, not size)
  3. Heavyweight plan: required sections
  4. Lightweight register: the issue IS the plan
  5. Non-negotiable planning rules
  6. Phase sizing (feeds epic-dev)
Original SKILL.md headings · 134 lines, 1,188 words
SKILL.md preview
---
name: implementation-planning
description: "Use this skill when the user asks to \"plan this feature\", \"write an implementation plan\", \"design before coding\", \"think through the approach\", \"review this plan\", or before any multi-file change, architectural decision, experiment with a go/no-go outcome, or strategic pivot. Produces a verifiable plan with pre-registered decision gates and an explicit list of open judgment calls."
---
> **LAB ADDENDUM (binding).** Adopted third-party skill: `neuromechanist/research-skills` @ `f0219bde233a` (BSD-3-Clause). Where anything below conflicts with the lab's rules, the lab's rules win.
>
> 1. **Evidence rule wins.** Facts and citations come only through `science-ultrapowers:verifying-evidence-by-doi` (peer-reviewed, DOI matched through Crossref, full text read, evidence record). Never cite from web search, model memory or preprints.
> 2. **Records.** Numbers and results come only from `science-ultrapowers:recording-findings` (FND-ids, `KEY_RESULTS.md`); work moves through the `science-ultrapowers:running-the-lab` stage approvals.
> 3. **No pre-approved tools.** Any upstream `allowed-tools` grant was removed from this copy, so normal permission prompts apply.
> 4. **Tools in Claude Code:** read PDFs with the file reader, edit with the file tools, read the skill's bundled files under `${CLAUDE_PLUGIN_ROOT}/skills/implementation-planning/`; packages the figure and poster skills need live in the project's `.venv-lab-skills` (see `science-ultrapowers:initializing-a-research-lab`).
> 5. **Not installed in this lab:** `agent-fanout` -> `science-ultrapowers:running-the-lab` (task assignments + delegation); `engineering-loop` -> `science-ultrapowers:running-the-lab` stage approvals; `epic-dev` -> `science-ultrapowers:running-the-lab` stage approvals.
> 6. **Skill-specific:** Store plans as `research_lab/experiments/preregistrations/<EXP-id>_plan.md`. The plan's preregistered decision points are Preregistration stage items (Academic Supervisor approval, recorded in the decision log); open judgment calls go to `research_lab/decisions/DECISION_LOG.md`; resolved decision points become findings log rows. The upstream model-routing section was replaced.
>
> Provenance, license and change log: `PROVENANCE.md`.


# Implementation Planning

Plans that a different (or weaker) model could execute without re-deriving
your reasoning, with success criteria fixed before any result is seen.

## Model assignment (lab addendum)

Use the strongest available model for problem framing, macro architecture, irreversible decisions and plan drafting. **Plan approval is a stage approval decision** (the Question or Preregistration approval, Academic Supervisor, recorded in the decision log), not a model choice. After approval, split the work into task assignments (see `science-ultrapowers:running-the-lab`) for the owning specialists, each assigned to the role. Write each task assignment so a specialist can execute it without reconstructing design intent.

## Pick the register (by stakes, not size)

| Situation | Register |
| --- | --- |
| Hard to reverse after shipping; touches privacy, auth, what data leaves the device, or public contracts; strategic pivot | **Heavyweight**: full plan document, user approval gate before executing (plan mode where available). |
| Known engineering backlog; the work is clear, there is just a lot of it | **Lightweight**: tracked issues carrying the full spec (template below); no separate plan document. |
| Single ordinary change | No formal plan; the engineering-loop skill's step order is the plan. |

The dividing line is reversibility and blast radius, not effort. A large
backlog of clear fixes needs no plan document; a small change to what an
external partner receives does.

## Heavyweight plan: required sections

```markdown
# Plan: <title> (issue #N)
## Context
[The evidence forcing this work, with numbers. What the previous phase or
investigation proved.]
## What already exists to reuse (do not rebuild)
[Named files/functions. Every plan must check this before proposing new code.]
## Approach
[The design, and one paragraph on why this and not the leading alternative.]
## Files
[New and modified, explicit paths.]
## Decision gate (set BEFORE looking at results)
[Crisp pass/fail: "X ships as default if metric A >= threshold on every
case AND metric B does not regress; if it fails, honest conclusion + named
fallback. No adoption of a non-passing candidate."]
## Prerequisites (user actions)
[Only the human can do these: account registrations, credentials, hardware.]
## Agent budget
[How many subagents this plan will spawn, worst case; see agent-fanout cap.]
## Open judgment calls
[Every ambiguity you resolved unilaterally, as a flagged list the reviewer
can veto. Silence on ambiguity is a defect.]
## Verification
[How each deliverable is proven: commands, thresholds, who runs them. For a
behavior-preserving refactor, the FIRST deliverable is the pin/
characterization test captured against the original code, per the
engineering-loop skill.]
```

## Lightweight register: the issue IS the plan

```markdown
## Symptom
[User-visible behavior, verbatim if reported.]
## Root cause
[file:line, what is wrong, the fixture/test/commit that proves it.]
## Fix
[Concrete, scoped change. DECIDED POLICY lines for any foreseeable ambiguity.]
Refs: #A, #B.
```

An implementer (human or agent) executes from the issue alone; that is the
test of whether it is written well enough.

For GitHub issue bodies, keep each paragraph on one source line and separate
paragraphs with blank lines. Do not apply sentence- or clause-level semantic
line breaks inside a GitHub paragraph. Semantic line breaks remain the default
for other prose source.

## Non-negotiable planning rules

1. **Verify load-bearing claims.** Before presenting any plan, list the 3-5
   facts that would break it if wrong, and re-check each one directly against
   source or live state, even when a trusted subagent supplied them.
2. **Pre-register gates.** Success/failure thresholds are written before the
   experiment or implementation runs. Re-running with adjusted parameters
   without disclosing that the original gate failed is prohibited.
3. **Check sibling documents.** Open issues, ADRs, and plan files in the same
   tracker may carry constraints on your deliverable that your source
   document does not restate. Surface contradictions before code starts.
4. **Reuse before rebuild.** The "already exists" section is mandatory;
   check the codebase and past research before proposing new modules.
5. **Separate decisions from details.** Batch every decision that needs the
   user (hard to reverse, quoted to third parties, spends real money or
   days of compute) into ONE structured question with 2-4 labeled options,
   one marked "(Recommended)", each with a one-line evidence-based rationale.
   Decide internal implementation details yourself and state them as facts.
   If a question times out unanswered, proceed with the recommended option
   and disclose that at the next checkpoint the user will read ("approving
   this plan also approves X").
6. **Persist the plan-of-record outside chat.** GitHub epic/issue plus a
   Definition of Done with measurable criteria; make gates self-enforcing
   where possible (a strict expected-failure test on the exact metric beats
   a prose checklist). Conversation history will be compacted; the tracker
   survives.
7. **New information reorders work.** When new input contradicts or gates a
   decision already acted on, stop downstream work, resolve the upstream
   decision first, state why the order flipped, then resume.
8. **Plans from subagents get verified, not trusted.** A planning agent must
   be read-only, cite file:line for its claims, and end with its own open
   judgment calls; you then re-verify its load-bearing claims (rule 1) before
   adopting the plan. Macro architecture uses the lead tier. A bounded phase
   elaborator may use the intermediate tier only after architecture approval;
   unresolved judgment returns to the lead.
9. **Kill cleanly.** When a gate fails, execute the named fallback: revert
   prototype code (with authorization), record the dead end (what was tried,
   what it cost, why it failed) in the tracker and scratch notes, and mark
   deferred ideas explicitly as deferred, never silently dropped.

## Phase sizing (feeds epic-dev)

One phase = one independently reviewable and testable pull request (PR):
roughly one subsystem, one migration, or up to ~500 net lines of
non-generated change.
If the description contains two or more such units, it is an epic (use
epic-dev); if not, it is a single feature (engineering-loop). Name phases
with 2-3 word kebab-case slugs: drop stopwords, keep the object noun first
("backend-metrics", "sync-engine", not "implement-the-new-backend-metrics").
Files in this package (3)
  • LICENSE 1 KB
  • PROVENANCE.md 2 KB
  • SKILL.md 9 KB

Versions

RepositoryScoreLicence
This page · raoofaltaher/science-ultrapowers100MIT
magnus919/agent-skills100MIT
neuromechanist/research-skills100BSD-3-Clause
w7Pratham/planning-skills100MIT
forgivesam168/ai-dev-workflow100Apache-2.0
cbrock84/headcount90MIT
zeeshanhanif/agentic-sdlc-kit90Apache-2.0
jagreehal/jagreehal-claude-skills90MIT
anotb/management-consulting-plugin85MIT

Database snapshot: 13.11.2026 · package version c85cfad2503d (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

  • 90work-planning
    Create a decision-complete implementation plan after repository-first discovery. Use for explicit planning requests or ambiguous, multi-step, high-impact work; do not use for already-scoped implementation, active debugging, review, or verification.
  • 80Rig Plan
    Produce a frozen implementation plan with owned paths, configured gates, risks, and acceptance criteria before code changes. Use for a multi-file or ambiguous change. NOT for a one-line edit or a read-only question.
  • 100new
    Create and manage implementation plans in .agent/plan/ files. Use this skill when: starting a new feature or refactor, the user says "plan this", "think about how to", "design the approach", "prepare a plan", or any time structured planning is needed before execution. Plans are…
  • 100plan-feature
    Structured feature planning workflow. Use when the user says "plan a feature", "design this", "how should we build", "feasibility check", or any pre-implementation planning work. Covers requirements, investigation, feasibility, and implementation planning.
  • 100plan
    Create and manage implementation plans in .agent/plan/ files. Use this skill when: starting a new feature or refactor, the user says "plan this", "think about how to", "design the approach", "prepare a plan", or any time structured planning is needed before execution. Plans are…
  • 90trove-plan
    Implementation planning workflow. Use after brainstorm approval or for multi-step work that needs verifiable checkpoints. Use when: write a plan; implementation plan; break this down; multi-step change.

Feedback and reports

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