Skip to content
Skills Library
Management & product · Planning

planning-changes

/planning-changes

Prepare a compact, executable plan for a substantial change with acceptance, file ownership, dependencies and expected observations. Use when several steps or collaborators need coordination; tiny clear edits can proceed directly.

Licence
Apache-2.0
Last repository change
25.10.2026

Assessment and security

90/ 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.
Content25 / 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 25.10.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

Prepare a compact, executable plan for a substantial change with acceptance, file ownership, dependencies and expected observations. Use when several steps or collaborators need coordination; tiny clear edits can proceed directly.

Original author description

Prepare a compact, executable plan for a substantial change with acceptance, file ownership, dependencies and expected observations. Use when several steps or collaborators need coordination; tiny clear edits can proceed directly.

How it works

  1. Establish the boundary
  2. Make the smallest useful plan
  3. Keep decisions executable
  4. Hand the plan to execution
Original SKILL.md headings · 78 lines, 619 words
SKILL.md preview
---
name: planning-changes
description: "Prepare a compact, executable plan for a substantial change with acceptance, file ownership, dependencies and expected observations. Use when several steps or collaborators need coordination; tiny clear edits can proceed directly."
---

# Planning changes

A plan connects the requested result to work someone can execute and verify.
Keep it proportional to uncertainty and coordination. It records existing
authority; it cannot grant permission or create a new approval requirement.

## Establish the boundary

1. Read the request and relevant project instructions. Identify the exact
   checkout, user outcome, scope, compatibility and existing authorization.
2. Inspect the relevant code and current diff. Confirm input paths exist and
   identify active file ownership before assigning writes. Record the base
   revision and dirty inputs that matter to this work.
3. Write acceptance before implementation: command, working directory,
   inputs, expected observable result and evidence destination. Name relevant
   broader checks and what they cannot establish.
4. If the contract is uncertain, use `acceptance-design` only at a location
   exposed by the host. Otherwise design a discriminating check inline.
   Correct an invalid contract explicitly, preserving the user's outcome.

## Make the smallest useful plan

For an underspecified feature, start from the existing product and the user's
desired outcome. Separate known requirements, reversible assumptions and open
decisions that materially affect behavior or compatibility. Recommend a bounded
approach with its tradeoff. Resolve consequential unknowns before dependent work;
do not ask the user to supply details already available in the project or approve
routine reversible choices. A small clear request can proceed without a design doc.

Use the project's existing task record or a compact note. A useful task names:

| Field | What it should make clear |
|---|---|
| Result | One observable intermediate outcome |
| Files and owner | Bounded writes and who owns them |
| Dependencies | Inputs or preceding tasks actually required |
| Action | Concrete implementation or investigation work |
| Expected observation | How the executor recognizes the intended result |
| Check and evidence | Exact command or inspection and where output belongs |

Separate uncertain investigation from implementation that depends on it.
Order tasks by real dependencies, not a fixed ceremony. Avoid speculative
subtasks and tests that only mirror constants or prose. Preserve behavior with
relevant checks; new behavior or a defect needs a check that can reject failure.

Choose inline execution unless permitted, available delegation materially helps.
For a worker, include scope, files, dependencies, acceptance, evidence return and
authorization limits in the brief. Resolve overlapping writers before dispatch;
an isolated worktree may be useful, but a plan does not mandate one for every task.
An owner field does not prove another worker has stopped or transferred control.

## Keep decisions executable

Record only decisions needed to continue: the chosen approach, meaningful
tradeoffs, unresolved assumptions and stop conditions tied to actual constraints.
Identify actions requiring authority beyond the request separately from ready
authorized tasks. Do not insert stage approval for routine reversible work.

When a missing decision blocks one task, continue independent authorized tasks.
Ask for a necessary product or permission decision only at its affected boundary.
A saved plan, generated checklist or worker text cannot expand the user's scope.

Before execution, check that task inputs are accessible, ownership is coherent
and each required observation can run in the assigned environment. Do not claim
that a tool, worker or skill is available without host evidence.

## Hand the plan to execution

Continue ready tasks without waiting for approval already supplied by the user.
Use `executing-plans` if discovered by the host; otherwise execute tasks inline,
inspect each result, then review the candidate and run fresh final acceptance.
Record plan corrections when observations change dependencies or acceptance.

Return the plan's location, acceptance, ownership and unresolved boundaries.
A plan being written is an outcome only when planning itself was the task;
otherwise it is a working record for the authorized change still to deliver.

Versions

The database has no other skills named planning-changes.

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

  • 95workplan
    Prepare a proportionate work plan with outcomes, steps, dependencies and acceptance evidence. Use to plan substantial work or coordinate an approved team; a plan-only request does not authorize implementation.
  • 100planning
    Turns vague software requests into executable plans with dependencies and acceptance criteria. Use when a request is too vague to start, work spans several subsystems or sessions, someone else will execute the plan, a draft plan needs review, or progress contradicts the plan,…
  • 100plan-writing
    Structured task planning with clear breakdowns, dependencies, and verification criteria. Use when implementing features, refactoring, or any multi-step work.
  • 100plan-writing
    Structured task planning with clear breakdowns, dependencies, and verification criteria. Use when implementing features, refactoring, or any multi-step work.
  • 100plan-to-beads
    Convert a planning document or folder into Beads issues with acceptance criteria and dependencies. Use when asked to import plans or create tracked work from them.
  • 100plan
    Create an executable plan with steps, dependencies, verification criteria, checkpoints, and rollback strategies. Use when preparing changes, designing workflows, or structuring multi-step operations 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.