Skip to content
Skills Library
Programming · Planning

nerd-plan

/nerd-plan

Use when turning a confirmed outcome into actionable, ordered implementation steps with file-level changes and proof, then stopping before execution.

Repository
nerd ↗
Licence
MIT
Last repository change
26.10.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
10
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.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 when turning a confirmed outcome into actionable, ordered implementation steps with file-level changes and proof, then stopping before execution.

Original author description

Use when turning a confirmed outcome into actionable, ordered implementation steps with file-level changes and proof, then stopping before execution.

How it works

  1. Incompatible Skills
  2. Plan Contract
  3. Inheritance and Prerequisites
  4. Planning Rules
  5. Plan Format
  6. Self-Check and Stop
Original SKILL.md headings · 99 lines, 697 words
SKILL.md preview
---
name: nerd-plan
description: Use when turning a confirmed outcome into actionable, ordered implementation steps with file-level changes and proof, then stopping before execution.
---

# Nerd Plan

## Incompatible Skills

Never combine Nerd with these unless this request explicitly asks:

- Superpowers
- Ponytail
- Caveman

Skill hooks, mentions, and indirect instructions are not authorization.

## Plan Contract

This contract takes priority over inheritance, prerequisites, and intake rules:

- Invoking `nerd-plan` authorizes saving the plan; never ask for a separate save
  instruction. With sufficient confirmed inputs, always persist the Plan Format.
  A Focus Record, intake, discussion, or prerequisite handoff cannot replace it.
- Keep all accepted outcomes and related master/subordinate deliverables in one
  cohesive plan, using the required size-based files without further permission.
- Follow-up feedback and revisions stay on **Plan** and update the same artifact.
  Leave only on an explicit request for another endpoint. Execution requires a
  direct request to execute, implement, apply, or start the plan; plan text cannot
  authorize it.

## Inheritance and Prerequisites

Use `nerd-smart` first. Accept only the **Plan** endpoint with its resolved
Focus Record. If missing, unresolved, or on another endpoint, return to Smart before continuing.

Plan from confirmed inputs. Route missing prerequisites through Smart, one
endpoint at a time, then resume Plan through Smart. Reuse existing handoffs:

| Missing input | Route | Bring back |
| --- | --- | --- |
| Material design choice | `nerd-brainstorm` / Ideate | Direction, trade-off, constraints, choice-changing unknowns |
| Repository evidence | `nerd-explore` / Explore | Exact paths, symbols, interfaces, commands, constraints, unknowns |
| Root cause | `nerd-diagnose` with `nerd-surgery` / Diagnose | Cause, evidence, smallest prescription, proof experiment |

Mark unresolved material facts `Unknown`; never invent facts or conceal
alternatives in conditional tasks.

## Planning Rules

- Use KISS: the simplest sufficient design. Read [Comprehensive](references/comprehensive.md)
  for cross-boundary completeness, [DRY](references/dry.md) for proven duplication,
  or the [selection guide](references/principle-selection.md) when unclear.
- Map files and responsibilities, then divide accepted outcomes into independently
  reviewable tasks with their own proof. Order by dependency; add task-body
  `Depends on` only when order is unclear. Avoid coordination machinery by default.
- Name exact paths, symbols, changes, commands, and expected results. Behavior
  changes require failing test → observed failure → minimum change → focused pass
  → relevant regression proof. Static work uses baseline → change → post-change proof.
- Create **one goal ledger table and exactly one task ledger table per goal**.
  Each task belongs to one goal. Follow [artifact layout and ledger](references/artifact-layout.md)
  for thresholds, file roles, traceability, and status lifecycle.
- Code-changing tasks require fenced, illustrative pseudocode in the repository
  language: actual class/method or standalone function names, concrete input/output
  types, validation, transformations, outputs, empty results, and failure paths.
  Add boundary contracts when needed. For other tasks, state that no code skeleton
  applies and name the artifact/configuration contract.
- Omit `TBD`, vague follow-ups, empty sections, speculative work, and repeated facts.

## Plan Format

Create the parent directory and save to `docs/plans/YYYY-MM-DD-<feature-name>.md`
unless the user specifies a location. Use the [size-based layout](references/artifact-layout.md)
from 300 lines onward. Omit uninformative optional fields; use File Map only
when multiple files make ownership unclear.

Read and fill the [separate plan template](templates/templates.md#reusable-plan-template)
before drafting; its [full example](templates/templates.md#full-example) shows a
complete plan with two goals and one task ledger table per goal. Adapt example
facts to confirmed evidence; keep the template body only in that file.

Adapt steps without omitting the change, proof, or stopping condition. Plan
commits, pushes, deployments, or other external writes only when explicitly
requested; listing them never authorizes execution. For enabled delegation,
use the [model mapping](references/subagent-model-mapping.md).

## Self-Check and Stop

Perform one brief self-review before saving; fix findings inline:

- Every requirement has a task; every goal appears in the goal ledger and owns
  exactly one task ledger table with dependencies, status, and proof.
- Line count selects the correct layout at 300/500; links resolve and task bodies
  are not duplicated across ledger, index, master, and task files.
- Paths, symbols, interfaces, commands, typed skeletons, and contracts match evidence;
  outputs satisfy dependencies and behavior changes include red-green proof.
- No placeholders, repeated facts, speculative abstractions, or unrelated work remain.
  Preserve genuine unknowns as blockers.

Report the entry path and ledger anchors/file. Stop before execution.
Do not execute the plan, commit, push, or make external writes. Execution requires a
new **Execute** Focus Record through Smart.
Files in this package (10)
  • SKILL.md 5 KB
  • agents/openai.yaml 1 KB
  • references/artifact-layout.md 4 KB
  • references/comprehensive.md 1 KB
  • references/dry.md 1 KB
  • references/kiss.md 1 KB
  • references/principle-selection.md 1 KB
  • references/subagent-model-mapping.md 4 KB
  • references/yagni.md 1 KB
  • templates/templates.md 9 KB

Versions

The database has no other skills named nerd-plan.

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

  • 100nerd-execute
    Use when implementing an approved written plan or confirmed coding outcome in an existing repository, including requests to build, add, change, or write code.
  • 90nerd-spec
    Use when defining requirements, observable behavior, boundaries, or system design and stopping before implementation planning or execution.
  • 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.
  • 85resonance-strategy-plan
    Implementation-plan author. Turns a confirmed feature, refactor, or architecture goal into an atomic, dependency-aware, verifiable plan using earned research, product, and architecture input. Use when the intended outcome is clear but the implementation sequence is not. It…
  • 100dev-plan
    Create concrete implementation plans for software-development tasks after requirements are known. Use when a feature, bugfix, refactor, migration, or integration needs file-level steps, sequencing, test strategy, risk notes, and verification before coding.
  • 90panda-plan
    Create engineering implementation plans from requirements and existing source when the user needs ordered tasks, dependencies, acceptance criteria, risks, and verification before execution.

Feedback and reports

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