planning-implementations
/planning-implementations
Use when a feature, refactor, or multi-file change needs to be designed before coding. Triggers: plan X, design the implementation, how should we build X, create an implementation plan.
- Author
- uw-ssec ↗
- Repository
- rse-plugins ↗
- Licence
- BSD-3-Clause
- Last repository change
- 14.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 14.10.2026, without references to retired models or APIs.
BSD-3-Clause, otwarta.
What it does and when to use it
Use when a feature, refactor, or multi-file change needs to be designed before coding. Triggers: plan X, design the implementation, how should we build X, create an implementation plan.
Original author description
Use when a feature, refactor, or multi-file change needs to be designed before coding. Triggers: plan X, design the implementation, how should we build X, create an implementation plan.
How it works
- Interaction mode
- Starting the skill
- Process
- References and output
- Common Mistakes
- Quality checklist
SKILL.md preview
---
name: planning-implementations
description: >-
Use when a feature, refactor, or multi-file change needs to be designed before
coding. Triggers: plan X, design the implementation, how should we build X,
create an implementation plan.
---
# Planning Implementations
Produce a comprehensive, phased implementation plan grounded in actual codebase
research, with measurable success criteria and no unresolved decisions.
## Interaction mode
This skill leans **Collaborative** by default. For the full Collaborative-vs-Direct protocol and override rules, see the Interaction Modes reference in the `ai-research-workflows:using-research-workflows` skill.
## Starting the skill
If no topic is given, enter Collaborative mode and ask what to plan (and check
`docs/rse/specs/` (then legacy `.agents/`) for existing research/prior-art). If the topic is given without a
research doc, look for `docs/rse/specs/research-*.md` matches and suggest running
`ai-research-workflows:researching` first if none are found — then proceed on user
preference.
## Process
### Step 1: Context Gathering
- Read all mentioned files **completely** before anything else.
- Check `docs/rse/specs/research-*.md` (and legacy `.agents/research-*.md`, `.agents/prior-art-*.md`) for relevant context.
- Investigate related files, existing patterns, integration points, and test
coverage in parallel where possible.
- Only ask questions that code cannot answer (product decisions, ambiguous
scenarios). Never ask "which database?" — read the code.
- In Collaborative mode, present findings and focused questions before
proceeding.
### Step 2: Research & Discovery
- Investigate in parallel: existing patterns, integration points, available
dependencies, current test coverage.
- **Wait for all research to complete** before synthesizing.
- In Collaborative mode, present design options with pros/cons and a
recommendation; get approval before continuing.
### Step 3: Plan Structure (Collaborative mode)
- Propose a phased breakdown with a one-line objective per phase.
- Get feedback before writing detailed steps.
### Step 4: Plan Writing
Generate filename from the topic slug (`plan-<slug>.md`). Read the template:
`assets/plan-template.md`.
**Required sections:**
1. Overview — what, why, high-level how
2. Current State Analysis — existing code with `file:line` references
3. Desired End State — observable success outcomes
4. What We're NOT Doing — explicit scope boundaries
5. Implementation Approach — technical strategy and key decisions
6. Implementation Phases — phased tasks with file paths and verification steps
7. Success Criteria — split into Automated and Manual (see below)
8. Testing Strategy — unit, integration, manual
9. References — research docs, files analyzed, external docs
Each phase needs: a clear objective, tasks with `path/to/file.ext:lines`,
dependencies on prior phases, and verification steps.
#### Bite-sized, test-first tasks
Each phase's tasks must be **executable steps an engineer can follow without
guessing**, sequenced test-first. Write the actual content, not a description:
- Sequence each unit of work as: write the failing test → run it, watch it fail
→ implement the minimal code → run the test, watch it pass → commit.
- Show the actual code or the exact command for any step that changes code or
runs something — never a paraphrase.
- Reference an exact `path/to/file.ext:line` for every task.
(For numerical/research code, the "failing test" is an assertion against a known
result, analytic case, or invariant — see `ai-research-workflows:hardening-research-code`.)
#### Blocking rule: NO placeholders
A step that says *what* to do without showing *how* is a plan failure. Never
ship any of these — resolve each before saving:
- "TBD", "TODO", "implement later", "fill in details".
- "Add appropriate error handling" / "add validation" / "handle edge cases" —
name the specific cases and show how each is handled.
- "Write tests for the above" without the actual test code.
- "Similar to Phase N" — repeat the code; phases may be executed out of order.
- Any reference to a type, function, or file not defined in some task.
#### Success Criteria split
**Automated Verification** — commands agents can run without human intervention
(`make test`, `pytest`, file-existence checks, linters).
**Manual Verification** — steps requiring human judgment (UI behavior, UX, edge
cases, performance under real conditions).
#### Blocking rule: NO open questions
If an uncertainty surfaces while writing, **stop**, then either research the
code to resolve it or ask the user. Resume only after it is resolved. A plan
section titled "Open Questions" with unresolved items is **not acceptable**.
### Step 5: Review & Iterate (Collaborative mode)
Present a summary (approach, phase count, criteria counts) and ask for feedback
on phasing, success criteria, technical approach, and edge cases.
For major revisions use the `ai-research-workflows:iterating-plans` skill.
## References and output
- Ground the plan in `docs/rse/specs/research-*.md` (and legacy `.agents/research-*.md`, `.agents/prior-art-*.md`);
incorporate `docs/rse/specs/experiment-*.md` (or legacy `.agents/experiment-*.md`) when present.
- List all referenced docs in the References section with relative markdown links.
- Create `docs/rse/specs/` if needed; write to `docs/rse/specs/plan-<slug>.md`.
- To revise an existing plan use `ai-research-workflows:iterating-plans`; to execute use
`ai-research-workflows:implementing-plans`.
## Common Mistakes
- **Confirming approach too late** — writing a detailed multi-phase plan before the user has approved the overall strategy wastes effort; in Collaborative mode, get approach sign-off after Step 2.
- **Placeholder tasks** — "add appropriate error handling", "write tests for the above", or any step that states intent without the concrete code/command is a plan the executor cannot follow; write the actual content.
- **Tests bolted on at the end** — lumping all tests into a trailing Testing Strategy section produces tests-last code; sequence tasks test-first (the failing test before the implementation) within each phase.
- **Vague success criteria** — "works well" or "passes tests" is not a criterion; every item must be a concrete, runnable command or an observable human-verifiable outcome.
- **Unsplit Automated vs Manual** — lumping all criteria together hides what requires human judgment; always separate the two categories explicitly.
- **Leaving open questions in the "final" plan** — a plan section titled "Open Questions" with unresolved items ships ambiguity to the implementer; resolve or explicitly defer every question before saving the plan.
- **Skipping scope boundaries** — omitting the "What We're NOT Doing" section lets scope creep in silently; fill it out even when the answer seems obvious.
## Quality checklist
Before completing the plan verify:
- [ ] All referenced files read completely
- [ ] All research completed and incorporated
- [ ] User consulted on approach and structure (Collaborative mode)
- [ ] Official template used
- [ ] Saved to `docs/rse/specs/plan-<slug>.md`
- [ ] Every phase has `file:line` references
- [ ] Phase tasks are bite-sized and test-first (failing test before implementation)
- [ ] No placeholder tasks ("add appropriate error handling", "write tests for the above", or intent-without-code)
- [ ] Success criteria split into Automated and Manual
- [ ] Criteria are measurable and concrete
- [ ] "What We're NOT Doing" section is filled out
- [ ] NO open questions remain
- [ ] References section links to research and experiment docs
Files in this package (2)
- SKILL.md 8 KB
- assets/plan-template.md 8 KB
Versions
The database has no other skills named planning-implementations.
Database snapshot: 13.11.2026 · package version 8016ad189e25 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 1 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100refactor-plan
Create a concrete plan before starting a multi-file refactor. Use when the user asks to plan, sequence, scope, or safely execute a refactor across multiple files; always investigate first, output the plan, and wait for confirmation before making code changes. - 100blueprint
Trigger immediately when the user says any of: 'design this', 'plan the implementation', 'plan this out', 'how should we build', 'implementation plan', 'before I write code', 'design the feature', 'figure out how to build'. Also use for implementation design once desired… - 100plan
Create a detailed implementation plan for a feature or task. Use when user wants to plan before coding. - 100claude-plan
Ask Claude Code to produce an implementation plan before you write code. Use when the task is complex, touches multiple files, or has unclear requirements. Claude returns a numbered step-by-step plan with file paths and interfaces — you implement it. - 100spec
Research a change against this codebase, then write it up as requirements plus a phased plan in docs/ before any code is written. Use for "plan this", "deeply analyse then plan", "audit this and tell me what we need", "what do we need for X", or before starting any new feature… - 100create-plan
Create detailed implementation plans through interactive research and iteration. This skill should be used when creating new implementation plans, designing feature specifications, planning technical work, or when the user asks to plan an implementation. Triggers on requests…