Results for “phase-plan”

Gather phase context through adaptive questioning before planning

Creates a machine-readable phased JSON plan bundle from a spec or feature description, producing a compact master manifest plus per-phase step files for resumable execution.

Execute all plans in a phase with wave-based parallelization

Surface Claude's assumptions about a phase approach before planning

Executes multi-stage release plans by reading a PHASE-PLAN.md, implementing each stage, running validation and critique gates, committing with clean scope, and advancing automatically, halting on repeated failures or unresolvable issues.

Decompose a single roadmap phase into implementation steps, tests, and file-level detail

Structured planning methodology with research, brainstorming, phased plan creation, risk assessment, and plan-to-build continuity.

Runs independent AI CLI reviewers over phase plans and merges their feedback into a REVIEWS.md file.

Generate implementation plans from approved designs — plan-generator, phase-based plans, parallel batch execution, task dependency graph, owner skill routing, acceptance criteria, global done criteria, plan frontmatter, layout contract, interaction contract, anti-drift rules, plan format, AD-2 byte-for-byte gate, scope definition, execution plan, phases and batches, task anatomy, plan file format

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 previous. Use when the user wants to plan, sequence, phase, slice, break down, or order the build of a feature, capability, system, or initiative, and produces a plain-language phased build outline. Does not produce implementation detail — use plan-implementation. Does not specify behavior that has not been decided — use plan-a-feature. Does not perform gap analysis between two artifacts — use gap-analysis. Does not break a plan into independently-grabbable work items — use plan-work-items.

Rolls back Open-workspace phase or plan commits using a phase manifest with dependency checks and a confirmation gate, preserving history via git revert.

Use when a research design spec exists and the user is ready to translate it into a concrete implementation plan with phased tasks, artifacts, and verification criteria. Produces a research execution plan organized in canonical research phases — collection, preparation, analysis, robustness, writing, submission.

Create a detailed, phased implementation plan with documentation discovery. Use when asked to plan a feature, task, or multi-step implementation — especially before executing with do.

Turns a raw idea into four linked planning files through a five-phase pipeline: clarifying questions, deep research, a PRD with non-goals and metrics, and a phased execution plan with kill criteria.

Build a compact, validation-gated implementation plan for multi-step, risky, or ambiguous work — typically when phases need explicit checkpoints, the change touches multiple files/services, or the user wants alignment before execution. Output goes to `.claude/plans/<topic>.md` (or `.agents/plans/`) with goal, in/out-of-scope, phased steps, validation per phase, and replanning triggers. Skip for trivial single-file fixes, bug investigations (use `tracer`), or open-ended exploration (use `explore`). Pair with `ship` once the plan ends and merge work begins.

Execute a phased implementation plan using subagents. Use when asked to execute, run, or carry out a plan — especially one created by make-plan.

Create comprehensive, phased implementation plans with sprints and atomic tasks. Use when user says: "make a plan", "create a plan", "plan this out", "plan the implementation", "help me plan", "design a plan", "draft a plan", "write a plan", "outline the steps", "break this down into tasks", "what's the plan for", or any similar planning request. Also triggers on explicit "/planner" or "/plan" commands.

Guides a structured planning pipeline for coding tasks, including scope detection, research, plan creation, and review.

Guides a structured planning pipeline for coding tasks, from scoping and research to plan creation, review, and handoff.

Plans and executes product launches with phased channel strategies. Use when the user requests 'product launch', 'GTM', 'go-to-market', 'Product Hunt', 'beta launch', 'early access', or 'launch checklist'.

Composite skill — safely refactor a module end-to-end with sequencing, parallel implementation, post-refactor cleanup, and rationale capture. Chains refactor-plan (phased plan + rollback) → three-man-team (architect/builder/reviewer in parallel) → fix-the-suite post-refactor → adr-write → docs-sync. Use for non-trivial refactors that need both careful sequencing and durable record.

Continues deep iteration on an existing planning document: detects explicit file-loading intent, provides status summaries, and supports on-demand in-depth exploration.

Create a detailed, step-by-step implementation plan for a feature or project. Load when the user asks to plan a feature, create a technical roadmap, break down a PRD into tasks, design an implementation strategy, or sequence engineering work. Also triggers on "how should we build this", "implementation plan for", "technical breakdown", "task list for", or any request to turn a high-level requirement into a concrete execution plan. Supports phased rollouts, architecture-first, and MVP-focused planning.

当感到生活迷茫、停滞不前，需要理解当前所处阶段并规划下一步行动时

6-phase iterative specification execution workflow covering implementation, testing, review, improvement, commit, and progress tracking with quality-gated convergence.

Spawns a researcher agent to investigate how to implement a project phase, gathering context on architecture patterns, standard libraries, and common pitfalls.

Plan a multi-file refactor with proper sequencing and rollback steps

Creates a concrete, multi-phase plan before starting a multi-file refactor, including affected files, dependencies, verification steps, and rollback procedures.

Runs a complete quality engineering audit on any codebase, deriving behavioral requirements, generating spec-traced tests, performing multi-pass code review, and producing a consolidated bug report with verified patches.

Archives phase directories from completed milestones into versioned archive folders, showing a dry-run summary and moving directories only after confirmation.