Skip to content
Skills Library
Programming · Planning

plan-work

/plan-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.

Licence
MIT
Last repository change
14.07.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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 14.07.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

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.

Triggers from the description

plan the implementationbreak down this taskcreate an implementation plan
Original author description

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.

How it works

  1. Investigation Phase
  2. Plan Structure
  3. Quality Checklist
  4. Finalize
  5. Principles
Original SKILL.md headings · 103 lines, 544 words
SKILL.md preview
---
name: plan-work
description: 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.
---

Enter plan mode using the `EnterPlanMode` tool, then produce a detailed implementation plan for the given issue. Plan mode enforces read-only access during investigation and gives the developer a structured approval flow before any changes are made.

Prioritize long-term correctness, maintainability, and idiomatic solutions over quick fixes.

## Investigation Phase

Use Explore agents and read tools to understand the problem. You are read-only in plan mode — use this constraint to investigate thoroughly before committing to an approach.

- **Verify understanding**: Confirm the problem statement and root cause
- **Map the implementation surface**: Identify files, functions, and data flows involved
- **Study patterns**: How does the codebase handle similar cases? Find existing functions and utilities that can be reused.
- **Check runtime behavior**: Gather logs, queries, or API responses as needed
- **Note constraints**: Performance, compatibility, security requirements

Use `AskUserQuestion` to clarify requirements or choose between approaches during investigation.

## Plan Structure

Write the plan to the plan file provided by plan mode. Structure it as follows:

### Context

Why this change is being made: the problem or need, what prompted it, and the intended outcome.

### Root Cause Analysis

- What's happening and why (with evidence)
- Sequence of events or data flow leading to the issue
- Key code references: `[filename.ext:line](path#Lline)`

### Solution Design

Address the root cause directly — no workarounds:

- Follow **idiomatic patterns** for the language/framework
- Respect **separation of concerns** — logic belongs in the appropriate layer
- Consider **idempotency** and **graceful degradation** for distributed systems
- Flag **breaking changes** clearly for developer confirmation
- Reference existing functions and utilities found during investigation, with file paths

**Alternatives Considered**: Document rejected approaches and why.

### Files to Modify

List each file with:

- Path and line reference
- Brief description of the change (1-2 sentences)
- Concise code snippet only if essential

### Implementation Steps

Numbered, actionable steps. Keep code examples minimal — show the essential change, not surrounding context.

Each step should be specific enough to execute without re-investigation.

### Verification

**Automated Testing:**

- Specific test commands to run
- New test cases needed (describe intent, not full implementations)

**Manual/Staging Verification:**

- Steps to validate in a running environment
- Log queries or monitoring checks
- Expected behavior vs. previous behavior

**Post-Deployment:**

- Deployment sequence if order matters
- Rollback criteria and procedure
- Monitoring queries for regressions

## Quality Checklist

Before finalizing:

- [ ] Follows idiomatic patterns for the language/framework?
- [ ] Addresses root cause, not just symptoms?
- [ ] Handles concurrent/distributed edge cases?
- [ ] Handles error cases appropriately?
- [ ] Is this the simplest solution that solves the problem?
- [ ] Breaking changes called out for developer confirmation?
- [ ] No injection, auth bypass, or data exposure risks?

## Finalize

Once the plan is complete and the quality checklist passes, call `ExitPlanMode` to present the plan for developer approval. Do not ask about plan approval via text or `AskUserQuestion` — `ExitPlanMode` handles this.

## Principles

**Prioritize**: Long-term correctness > backward compatibility > implementation speed

**Avoid**:

- Leaking internal details across layer boundaries
- Over-engineering (extra config, abstractions, or features not requested)
- Ignoring existing codebase patterns
- Large code blocks — summarize or show only the essential diff

Versions

RepositoryScoreLicence
This page · znorris/claude-marketplace100MIT
yowcow/dude100MIT
pinkroosterai/PinkRoosterSkills100MIT
daniel-kindl/dkstack100MIT
hiteshdundi01/shipwright100MIT

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

Downloads in the last 30 days: 2 · ranking

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

Similar skills

  • 100plan
    Create a structured implementation plan with goal, acceptance criteria, incremental Code-First Small Batches steps, and a pre-PR quality gate. Use this for tasks that need a plan but not the full three-phase orchestration, or when the user says "plan this", "make a plan", "break…
  • 90implementation-plan
    Convert a plan, PRD, backlog item, or vague feature into ordered implementation work with acceptance criteria and verification. Use when the user asks to break down work, make an implementation plan, create tasks, plan execution, or use slice-plan.
  • 100planner
    Use when the user asks to create a new implementation plan, break down a task, plan a bug fix, plan a feature, or write a phased execution plan. Do not use when a plan already exists and the user wants implementation, review, or sprint scoping.
  • 100sl-ds-ticket-to-plan
    Turns a GitHub issue of the SL Design System (sl-design-system/components) into draft acceptance criteria for the developer to confirm, then into an implementation plan mapped to this repository's files. Use it when a design-system developer starts work on an issue, asks what an…
  • 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.
  • 100planning-and-task-breakdown
    Decompose specs into small, ordered tasks with acceptance criteria and verification steps. Use when you have requirements and need an implementable plan or task list. Triggers: "break down tasks", "implementation plan", "task breakdown", "plan mode".

Feedback and reports

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