app-plan-feature-stories
Decompose a piece of work into a 3-tier Feature > Story > Task plan tree, written to disk as self-contained markdown files. Use when the user asks to plan a feature, break down work, write an implementation plan, or create a task tree for a larger effort.
- License 许可
- MIT
- 最近更新
- 2026-08-25
- Stars
- ★ 0
- Forks
- 0
01 前言 Front Matter
- name
- app-plan-feature-stories
- tier
- app
- description
- Decompose a piece of work into a 3-tier Feature > Story > Task plan tree, written to disk as self-contained markdown files. Use when the user asks to plan a feature, break down work, write an implementation plan, or create a task tree for a larger effort.
03 SKILL.md 正文
Plan: Feature > Stories > Tasks
Decompose work into a 3-tier hierarchy written to disk. Each file is self-contained and independently actionable.
This skill mirrors the slash command /plan-feature-story-task. Use it when a model does not auto-load slash commands or the user invokes the skill explicitly.
Input
The user provides a description of work to be done. It may be vague or detailed. Understand it deeply before decomposing.
Workflow
Phase 0: Name the Plan Directory
Format: <suggested_name>-<date>-<session_id>
<suggested_name>— short kebab-case slug (max 4 words) derived from the work (e.g.,auth-middleware-rewrite,api-rate-limiting)<date>— today's date inYYYYMMDD(e.g.,20260416)<session_id>— short UUID v4 prefix, 8 hex chars (e.g.,a1b2c3d4)
Example: auth-middleware-rewrite-20260416-a1b2c3d4
Place under the project root at ./plans/<suggested_name>-<date>-<session_id>/. All references below to <plan-dir>/ point here. If the user specifies a different location, use that instead.
Phase 1: Understand
- Read the user's request carefully.
- Explore the codebase to understand relevant code, architecture, patterns.
- Ask clarifying questions if scope, goals, or constraints are ambiguous. Do not proceed until context is sufficient.
Phase 2: Decompose
Three levels:
Feature — a distinct, deliverable capability. "What does the user/system gain when this is done?"
- Independently shippable
- Named by capability delivered, not implementation detail
Story — a behavior slice within a feature. "What specific behavior changes when this story is complete?"
- One observable change (user-facing or system-facing)
- Orderable by dependency within a feature
- Completable in a single focused session
Task — an atomic implementation step within a story. "What exact code change do I make, and how do I verify it worked?"
- Targets specific files with specific changes
- Minutes to hours, not days
- Includes verification steps (test, behavior check, command)
Phase 3: Write the Plan
Create this tree under ./plans/<plan-dir>/:
<plan-dir>/
├── README.md
├── features/
│ ├── 01-<feature-name>.md
│ └── 02-<feature-name>.md
├── stories/
│ ├── 01/
│ │ ├── 01-<story-name>.md
│ │ └── 02-<story-name>.md
│ └── 02/
│ └── 01-<story-name>.md
└── tasks/
├── 01/
│ ├── 01/
│ │ ├── 01-<task-name>.md
│ │ └── 02-<task-name>.md
│ └── 02/
│ └── 01-<task-name>.md
└── 02/
└── 01/
└── 01-<task-name>.md
Naming: <NN>-<kebab-case-name>.md. Numeric prefix preserves ordering. Stories and tasks are grouped by their parent's feature number.
File Templates
<plan-dir>/README.md
# Plan: <Plan Title>
## Goal
<What this plan achieves — 2-3 sentences>
## Scope
<In scope and explicitly out of scope>
## Features
| # | Feature | Stories | Description |
| --- | ------------------------------------------- | ------- | ---------------- |
| 01 | [Feature Name](features/01-feature-name.md) | N | One-line summary |
## Execution Order
<Recommended order, noting dependencies>
<plan-dir>/features/NN-feature-name.md
# Feature: <Feature Title>
## Goal
<Capability this feature delivers — 1-2 sentences>
## Acceptance Criteria
- [ ] <Observable outcome 1>
- [ ] <Observable outcome 2>
## Stories
| # | Story | Tasks | Description |
| --- | -------------------------------------------- | ----- | ---------------- |
| 01 | [Story Name](../stories/NN/01-story-name.md) | N | One-line summary |
## Notes
<Architectural decisions, constraints, context specific to this feature>
<plan-dir>/stories/NN/NN-story-name.md
# Story: <Story Title>
**Feature:** [<Parent Feature Name>](../../features/NN-feature-name.md)
## Context
<Why this story exists and what behavior it changes — enough to understand without reading the parent>
## Acceptance Criteria
- [ ] <Testable behavior 1>
## Dependencies
- <Other stories this depends on, with paths, or "None">
## Tasks
| # | Task | Description |
| --- | ---------------------------------------------- | ---------------- |
| 01 | [Task Name](../../tasks/NN/NN/01-task-name.md) | One-line summary |
<plan-dir>/tasks/NN/NN/NN-task-name.md
# Task: <Task Title>
**Story:** [<Parent Story Name>](../../../stories/NN/NN-story-name.md)
## Context
<What this task accomplishes and why — enough to execute without reading parent files>
## Target Files
- `<path/to/file.ext>` — <what changes>
## Changes
<Specific code changes. Concrete: function names, data structures, logic flow.>
## Verification
- [ ] <Command to run, test to check, behavior to observe>
Rules
- Self-contained files — every file includes enough context to act on independently.
- Relative links — all cross-references use relative markdown links.
- No empty shells — every field has real content. If you cannot fill a field, decomposition is not detailed enough — investigate further.
- Concrete tasks — name specific files and describe specific changes. "Update the config" is not a task. "Add
rateLimitPoolfield tosrc/config/schema.mjswith Zod enum validation" is a task. - Verify before writing — confirm file paths, function names, and patterns by reading actual code before referencing them.
After Writing
Summarize to the user:
- Total count: N features, N stories, N tasks
- Recommended execution order
- Risks, open questions, or decisions needing user input
Reference
Source command: .claude/commands/plan-feature-story-task.md.
04 同仓库更多 Skills
validation_handoff
Forces the agent to conclude its response by generating a strict validation checklist and outlining pending actions, focusing heavily on defensive execution and edge-case testing.
project-ployglot-project-scafford
Scaffold a polyglot library project as TypeScript + Python twin packages under `packages/ts/` + `packages/py/`, with a shared `SPEC.md`, cross-language `tests/parity/fixtures.json`, side-by-side `examples/sdk/` + `examples/api/` documentation, per-package `Makefile`, and a root orchestrator that exposes `make ci`. Open-source friendly — no organization-specific paths or scopes baked in. Use when starting a new polyglot library, porting a single-language library to a twin, or auditing/regularizing an existing two-language repo against the canonical layout.
playwright-ui-locator
Auto-heal Playwright tests after a frontend developer changes a div's class, id, or other selector. Catches a failing Playwright test, captures the old vs new DOM tree, finds the element that drifted, derives the most stable replacement locator, and proposes the fix as a GitHub pull request (confident heals) or files a GitHub issue (ambiguous / element-removed cases) — never editing the working tree directly. Trigger when Playwright tests fail with "locator resolved to 0 elements", "Timeout waiting for selector", or after a UI refactor / class rename / Tailwind cleanup broke previously-passing tests.
org-learn-context-window
Distill the current conversation into a reusable command or skill artifact. Use when the user wants to capture a workflow they just executed (create a reusable slash command) or formalize a resolution/mistake/correction into a reusable skill so the same class of issue never recurs.
org-agent-skill-creator
Scaffold and validate scope-aware agent skills (company, enterprise, org, team, project, application). Use when the user asks to create a new agent skill, generate a SKILL.md file, scaffold a skill directory, or validate that existing skill directories meet SKILL_SPEC.md (frontmatter, naming rules, structure, scope/tier).
app-workshop-session-pdf-recap-next
Extract content from a workshop session PDF and produce a structured recap focused on (1) what was learned, (2) next steps, and (3) possible enhancements. Ingests a single PDF file path, parses session material (slides, transcripts, exercises, Q&A), and emits a Markdown report with Learning Recap, Next Steps, and Enhancement Opportunities sections with page-level traceability. Use when the user asks to "summarize a workshop", "recap a training PDF", "pull next steps from a session deck", or provides a workshop/seminar/tutorial PDF and wants a learn-and-act summary.