# Plan To Launch

> End-to-end software development workflow for AI agents. Use for plan-to-launch, dev workflow, PRD, DD, design doc, council on docs, implementation plan, ship, code-reviewer, council on review and code, launch PR, merge readiness. Enforces thought-out plan before implementation, bounded PRD/DD council loop, ship/review loop, design kickback, human approval, agent-fleet awareness, telemetry, long-term memory, and code RAG.

- Skill: `zhachory1/plan-to-launch` (Agent Skill)
- Install (CLI): `npx skillmds@latest add zhachory1/plan-to-launch`
- Raw SKILL.md: https://api.skillmd.com/api/skills/zhachory1/plan-to-launch/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Product & Planning
- Author: Zhachory1 (https://skillmd.com/u/zhachory1)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/zhachory1/plan-to-launch

---


# Plan to Launch

Ensure a thought-out plan exists before implementation. Move from product intent to technical design, council stress-test, executable plan, `ship`, code review, final council, and human launch approval.

## Core Principles

**Intent before code.** PRD and DD must be good enough before implementation starts.

**Cheap failures first.** Catch wrong assumptions in docs and council, not after code exists.

**Ship follows accepted plan.** Implementation should satisfy planned tasks and flag plan/design mismatches instead of silently inventing fixes.

**Material expansion renews approval.** Discovery does not amend accepted scope. Pause implementation and obtain human approval for recorded material scope delta before continuing.

**Review checks fidelity.** Code-reviewer judges correctness and whether code still matches PRD/DD intent.

**Loops are bounded and delta-only.** Re-review only raised issues and changed material.

## Inputs

- product or user goal.
- target repo and branch.
- existing docs, tickets, issues, prior decisions, code context.
- success metrics or constraints.
- run id and budget caps.

## Tool Awareness

Use `grounding-brief` with long-term memory MCP, code RAG, git, tickets, PRs, and agent-fleet journals. Use agent-fleet `/council` for required minimal/full councils after `AGENT_FLEET_HOME` preflight. Use agent-fleet `/ship` or local `ship` skill for implementation when plan is accepted. Use `run-telemetry` at each gate.

## Council Policy

Use agent-fleet council levels: `none`, `single-lens`, `minimal-council`, or `full-council`. Low-risk, reversible work may record `council_level: none` or use `single-lens`; docs and final code councils are required only when risk, ambiguity, conflicting review, unresolved blocker, design mismatch, security/privacy/reliability concern, or leadership-visible tradeoff appears. Required `minimal-council`/`full-council` must block if agent-fleet preflight fails.

## Workflow Modes

- `lite`: accepted small change; produce scope lock, focused plan, patch/review handoff. Budget: focused refs, one artifact, `council_level` max `single-lens`, loop cap 1, focused validation.
- `default`: normal feature/change; PRD/DD may be lightweight, task plan required, council only if risk triggers. Budget: selected docs, up to two artifacts, `council_level` max `minimal-council`, loop cap 2.
- `deep`: high-risk architecture, launch, security/reliability, cross-team, or leadership-visible work. Budget: full docs, required gates, council allowed with reason.
- Escalate: ambiguity, design mismatch, unresolved blocker, risky rollout, or conflicting review.
- Load: start with this skill and user artifact; load doc templates, agent-fleet council protocol, handoff, or telemetry references only when that gate will run.

## Execution

Run only the steps required by selected mode. `lite` may use scope lock instead of formal PRD/DD; `default` may use lightweight PRD/DD; `deep` uses full docs and gates.

**Ground context.** Invoke `grounding-brief` over user goal, memory, code RAG, existing docs, related PRs, issues, and prior runs. Do not propose infrastructure until its capability reuse inventory is complete.

**Lock scope.** Before implementation, record a scope fingerprint: intended files, effort, systems, trust/deployment/rollback boundaries, and issue-wide implementation PR count.

**Author PRD.** Use `structured-doc-authoring` to define what, why, users, scope, non-goals, success criteria, and launch readiness. Use `success-criteria-metrics` to lock the primary outcome and guardrails.

**Author DD.** Use `structured-doc-authoring` to translate PRD into architecture, boundaries, data/control flow, tradeoffs, tests, observability, rollout, risks, and alternatives.

**Council on docs.** Select council level from risk: `none` for low-risk clear docs, `single-lens` for one domain concern, and agent-fleet `minimal-council`/`full-council` only for multi-domain or high-risk design decisions. Required council verdict must pass or pass-with-nits before planning only when council level is minimal/full.

**Scope expansion gate.** Pause implementation and invoke `human-approval-gate` when review or discovery adds infrastructure or a trust boundary; doubles expected files, effort, or systems touched; raises issue-wide implementation PR count above two; turns configuration/integration into platform capability; or changes deployment/rollback semantics. Package original scope fingerprint, discovery, smallest options, added cost/risk, and recommendation. Emit gate/escalation telemetry with reuse candidate outcomes/count, expansion reason, and renewed approval state. `approve` resumes only when tied to fingerprint; `reject` ends paused run; `revise` returns to design and remains paused; `extend budget` approves recorded cap only. No response remains pending, and later delta repeats gate.

**Write plan.** Use `task-decomposition-planning` to create ordered implementation tasks with dependencies, acceptance criteria, validation, rollout, and stop conditions.

**Ship tasks.** Use agent-fleet `ship` for each accepted task or slice, with at most two issue-wide implementation PRs unless human approval extends cap. If implementation exposes design error, stop and return to DD instead of patching around it.

**Run code-reviewer.** Review for correctness, safety, maintainability, security, performance, tests, observability, and fidelity to PRD/DD. Re-review only deltas after fixes.

**Council on review and code.** Use agent-fleet `/council` only when review findings conflict, blockers remain unresolved, implementation reveals design mismatch, or risk level justifies a final merge/no-merge council against original intent.

**Launch PR.** Use `handoff-packaging` to create PR package with linked docs, rationale, tests, council verdicts, and known limitations. Use `human-approval-gate` for final signoff.

## Loop Controls

**Doc loop.** PRD/DD and agent-fleet council gate iterate only when council level is minimal/full; otherwise record skipped or single-lens reason and proceed when doc acceptance criteria are met.

**Implementation loop.** `ship` and code-reviewer iterate until review has no blockers, cap hit, or plan mismatch discovered.

**Outer design kickback.** If final council or review evidence finds design intent wrong, return to DD and preserve implementation learnings as evidence. A material delta pauses the run until human approval for its scope fingerprint; telemetry is evidence, not gate authority.

**Delta-only rule.** Re-council and re-review focus on required changes, not settled material.

**State carry-forward.** Maintain decisions, rejected alternatives, review issues, and plan mismatches in the run directory.

## Output Contract

```markdown
# Dev Workflow Run

## Artifacts
- PRD:
- DD:
- council docs level/verdict:
- implementation plan:
- shipped tasks:
- code review:
- final council level/verdict:
- PR package:

## Gate State
- docs: pass | pass-with-nits | block
- implementation: clean | needs-fix | design-kickback | paused
- scope fingerprint:
- scope renewal: not-required | pending | approved | rejected | revision-requested
- paused action / resume condition:
- delivery PR budget: count, approved cap, deferred work
- final: launch | revise | escalate-human

## Evidence
- tests:
- validation:
- linked PR/docs:
- telemetry path:
```

## Success Criteria

- PRD/DD or scope lock exists before implementation, according to selected mode.
- council docs gate either records skipped/one-lens reason or passes when minimal/full council is triggered.
- task plan or lite task list has acceptance criteria and dependencies.
- material scope expansion emits a human approval gate and pauses implementation.
- delivery uses no more than two issue-wide implementation PRs without explicit approval.
- telemetry records reuse candidates, scope expansion, and renewed approval state.
- shipped code maps to planned tasks.
- code-reviewer blockers resolved or escalated.
- final council confirms merge/no-merge call only when escalation matrix triggers it; otherwise skipped reason is recorded.
- launch package and human approval ask exist.
- `run-telemetry` events emitted for all major gates.

## Common Failure Modes

**Skipping docs for speed.** Fix by writing lightweight PRD/DD, not by jumping to code.

**Council churn.** Fix by agent-fleet caps, delta-only review, and human escalation.

**Implementation invents new design.** Fix by DD kickback.

**Review drifts from intent.** Fix by linking every blocker to PRD/DD, code evidence, or safety risk.

## Self-Improvement

Record which gates found real defects, which council blockers were false positives, where plan missed implementation reality, and where human reviewers edited PR package. Feed these into `backprop` for workflow optimization.