Results for “phased-plan”

Executes a phased implementation plan by deploying subagents for implementation, verification, anti-pattern checks, code quality review, and committing.

Deep audit of a skills directory against the Skill Creator standard. Produces a scored report and phased remediation plan.

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.

Plan product launches, feature announcements, and release strategies using phased approaches, channel mapping, and momentum-building tactics.

Builds a strategic SEO plan for new or existing websites, covering competitive analysis, site architecture, content strategy, technical foundation, and a phased implementation roadmap.

Transforms a raw product idea into four planning files: clarifying questions, deep research, a PRD with non-goals and metrics, and a phased execution plan with kill criteria.

Creates a strategic SEO plan for new or existing websites, covering competitive analysis, site architecture, content strategy, technical foundation, and a phased implementation roadmap.

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.

Builds a strategic SEO plan for new or existing websites, covering competitive analysis, site architecture, content strategy, technical foundation, and a phased implementation roadmap with industry-specific templates.

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.

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.

Execute phased plans with multiple independent tasks per phase by fanning out one agent per task, reconciling outcomes per wave, gating between phases with verify commands, and emitting a phase × outcome report. Triggers include "execute this plan", "work through these phases", "swarm over this backlog", "parallelize this plan".

Audit whether a project can actually recover from data loss — not just whether backups exist — then emit a phased DR plan. Use when "can we recover if the DB dies", "audit our backups", "what's our RPO/RTO", or "disaster recovery". Plan only. Destructive-op gates stay on plan-data-integrity.

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.

Five-phase pipeline (triage → clarify → research → PRD → plan) that turns a raw idea into four linked files: clarifying questions, deep research, a PRD with non-goals and metrics, and a phased execution plan with mermaid user journey and 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.

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'.

Create detailed phase plan (PLAN.md) with verification loop

Execute all plans in a phase with wave-based parallelization

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

Five-phase pipeline (triage → clarify → research → PRD → plan) that turns a raw idea into four linked files: clarifying questions, deep research, a PRD with non-goals and metrics, and a phased execution plan with mermaid user journey and kill criteria.

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

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

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.

Breaks a PRD into a multi-phase implementation plan using tracer-bullet vertical slices, saved as a local Markdown file in ./plans/.

Decompose multi-step work into a revisable subgoal plan with stable step IDs, checkpointing, and plan-ahead execution. Load when a task needs explicit planning before action, subgoal decomposition, plan checkpointing, or ReCAP-style plan-ahead execution. Also triggers on "structured plan", "plan with steps", "subgoal graph", "revise the plan", "checkpoint plan", or multi-step tasks where naive one-shot execution would be fragile. Skips trivial single-step tasks. Pairs with dynamic-routing on failure. Distinct from process-decomposer (registry/triage) and problem-to-plan (doc deliverables).

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.

Decomposes an approved specification into dependency-aware waves and atomic executable tasks with exact file scope, test-first actions, verification commands, and an execution gate.

Model a Phase-Locked Loop (PLL) IC from its datasheet or system specs using Mixed-Signal Blockset. Without this skill, agents universally select the wrong solver and produce non-functional PLL models — 100% of unguided attempts fail. Covers Integer-N, Fractional-N, Dual Modulus architectures, loop filter design, lock time optimization, VCO phase noise configuration, and msbPllArchitectures/msbPllFoundation block assembly. Use when: PLL modeling, frequency synthesizer design, phase noise simulation, lock time analysis, charge pump design, loop filter tuning, datasheet-to-model, Mixed-Signal Blockset PLL, msbPllArchitectures.

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.