plan-a-phased-build

Solid

Splits a body of context into a sequence of vertical-slice build phases where each phase is independently demonstrable to a real user and each builds on the work of the previous. Use when the user wants to plan, sequence, phase, slice, break down, or order the build of a feature, capability, system, or initiative — including requests like "split this into phases", "what should we build first", "create a build plan", "phase this work", "turn this into vertical slices", "outline the order of delivery", or "what's our roadmap". Accepts any source of context — gap analyses, PRDs, design documents, feature specifications, conversation notes, ADRs, requirements lists, or inline descriptions — and produces a plain-language `build-phase-outline.md` indexed by stable phase IDs. Each phase explains what gets built, why it lands at that position, the outcome a real person can be shown end-to-end, cross-references back to the source artifact for traceability, and preconditions. Foundational or prerequisite phases appear

Web & Frontend 66 stars 5 forks Updated today MIT

Install

View on GitHub

Quality Score: 88/100

Stars 20%
61
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
50
License 10%
100
Description 5%
100

Skill Content

## Project Context - CLAUDE.md: !`find . -maxdepth 1 -name "CLAUDE.md" -type f` - project-discovery.md: !`find . -maxdepth 3 -name "project-discovery.md" -type f` ## Operating Principles - **Plain language is the default surface.** The build-phase outline never contains file paths, line numbers, function or class names, library mechanics, or language primitives. It uses product-level subsystem names ("the events processing system", "the database"), user-facing UI vocabulary (popover, modal, toast), behavioral verbs (publishes, retries, expires), and user-observable states. Brand names generalize one level up — "PostgreSQL" → "the database", "NATS JetStream" → "the events processing system". A non-technical stakeholder must be able to read the document end-to-end. - **Every phase must be demonstrable to a real person.** "Demonstrable" means a person can be put in front of the running result and see something happen end-to-end — not "we shipped a service", but "you can do X and Y happens". If a phase is not demoable, it is either too small (merge it forward into the next phase that does become demoable) or too horizontal (it is a layer, not a slice — re-think it as a thinner end-to-end strip). - **Every phase builds on the prior.** As phases ship, the system becomes progressively more capable. Earlier phases stay valid; later phases enrich what earlier ones delivered. Never sequence a phase so that it invalidates an earlier deliverable. - **Vertical slices, not horizontal la...

Details

Author
testdouble
Repository
testdouble/han
Created
3 weeks ago
Last Updated
today
Language
Shell
License
MIT

Integrates with

Similar Skills

Semantically similar based on skill content — not just same category

Web & Frontend Listed

build

Implement one phase of a plan. Reads plan, finds next incomplete phase, implements it, runs feedback loops, marks checkboxes, offers commit. One phase per invocation. Use when the user wants to implement, code, build, or work on the next phase of a plan.

0 Updated today
bimetallic-seascallop841
Code & Development Solid

plan-a-feature

Builds a feature specification from scratch through a relentless, evidence-based interview that walks the design tree decision-by-decision, resolving dependencies as it goes. Use when the user wants to plan, design, scope, specify, or flesh out a new feature, capability, or system behavior before implementation — including requests like "help me plan X", "spec out this feature", "design the Y flow", or "let's figure out what it should do". Explores the codebase, project documentation, coding standards, and ADRs to resolve questions before asking the user, and always offers a recommended answer when questions must be surfaced. Produces a feature-specification.md focused on system behaviors, coordinations, processes, and user interactions — not implementation detail. Does not refine or stress-test an existing plan — use iterative-plan-review. Does not investigate bugs or failures — use investigate. Does not analyze existing architecture — use architectural-analysis. Does not document already-built features — us

66 Updated today
testdouble
Web & Frontend Listed

plan-first-development

Break complex projects into detailed multi-phase plans before writing any code. Prevents scope creep, refactoring waste, and missed requirements. Use when starting any project with more than 1000 lines of code or building systems with multiple interacting components.

6 Updated 3 months ago
maschad
Code & Development Listed

phasing

Orchestrate multi-phase work across fresh Claude sessions with mandatory plan-mode gating and self-verification. Use this skill whenever a user has a plan or task that touches multiple subsystems, has natural break points, would benefit from re-grounding mid-execution, or when the user wants to stay in the loop on every decision instead of dispatching subagents. Trigger this when a presented plan looks too big for one execution, when the user invokes /phase, or when a user mentions phasing, breaking work into chunks, multi-step implementation, or wanting fresh context between work units. Even if the user doesn't explicitly say "phase it," consider this skill whenever a plan spans backend + frontend + DB, has 8+ task items across different domains, or where context rot in a single session is likely.

0 Updated 4 days ago
unifylabs-dev
Web & Frontend Solid

plan-phase

Plan the next PRD phase by drafting issues, creating GitHub issues, and bridging planning to building.

416 Updated yesterday
joshukraine