plan — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited plan (Agent Skill) and scored it 96/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 1 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 1 flagged
The text {match} tells the agent to skip the normal "ask the user first" gate. Used adversarially it removes the human-in-the-loop check before destructive or sensitive actions, turning a normally-gated agent into a fire-and-forget executor.
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
Orchestrate a planning conversation that produces one thing: a plan a fresh agent can execute and a moderately experienced non-developer can read. The method is interview-driven, risk-first, adversarially-reviewed, and mechanically-validated — more rigorous than single-pass planning, without document sprawl.
CRITICAL: This is PLANNING MODE. Do NOT write implementation code. Do NOT create source files. Produce the plan only.
CRITICAL: The planner writes at most three files, all under `docs/`:
plan.md — always (the plan).prd.md — only when it's missing or skeletal, only drafted from the user'sown interview answers, and only with per-section confirmation (Phase 1's PRD gap check). Never edited when a real PRD already exists — changes to an existing PRD go in the update-prompt.
[date]-update-prompt.md — only when the conversation surfaces a change thatbelongs in a durable doc the planner does not own (an existing PRD, decision log, architecture).
Validate & Risk → Review → Export.
references/discovery-interview.md to settled-or-explicitly-unknown, mirrors the project back for correction, and proposes assumptions for confirm/deny.
fully specced), Next (V1 outline), Later (end goal themes). Detail decays with distance by design.
goal-backward, sequences risk-first with size discipline, specs every task to execution-readiness, then mechanically validates and adversarially reviews the plan.
stack-advisor and risk-assessor — with JSON outputcontracts validated by scripts/validate-json.py.
scripts/plan-lint.py against plan.md: required sections, per-task fieldpresence, dependency resolution, no vague language. Real validation, not a model self-check.
status, or operating-manual docs — those surface into the update-prompt.
docs/./rad-planner:replan pulls them in.
dependency integrity, and vague language. risk-assessor handles judgment calls.
Understand the project before planning anything. Full protocol: references/discovery-interview.md — load it first.
Pre-discovery scope check. If the project idea is still fuzzy — the user is debating what to build or whether the problem is the right one — stop and recommend /rad-brainstormer:brainstorm-session or /rad-brainstormer:design-sprint. Planning assumes the what is decided; it plans the how and order. (A messy existing project with unclear state is different — that's /rad-planner:rescue.)
Pre-fill from evidence. Glob the working directory.
docs/prd.md,docs/handoff.md, any existing docs/plan.md, CLAUDE.md / AGENTS.md, README.md, the manifest (package.json or language equivalent), top-level config — plus a Glob of the directory structure. The PRD is product authority: plan against it, and surface any contradiction as a question, never a silent override. Never ask what the repo already answers — confirm instead.
Run the interview per the protocol: round 1 questions across the eight coverage areas (end goal, users & workflow, MVP, success criteria, constraints, assets, exclusions, danger zones) → mirror the project back for correction → follow-up rounds on unsettled areas only, capped at 3 → propose 3–6 assumptions for confirm/deny. Plain language throughout; AskUserQuestion for choice-shaped questions.
Close with the two gates (both in references/discovery-interview.md):
full plan? The user chooses; recommend full for greenfield, quick for a feature in an established codebase.
docs/prd.md is missing or skeletal, offer to draft itfrom the interview answers, confirming each section (apply / reword / skip) before writing. The PRD content is the user's answers reorganized — never invented. After writing, stamp its **Updated:** date. If the user declines, note the gap in Key assumptions and continue.
(Skipped on the quick path, or when the stack is settled and the work introduces nothing new — note that and move on.)
Evaluate the technology stack when a stack decision is in play — a new project, or existing work adopting new frameworks/services.
Delegate to the stack-advisor agent using references/subagent-prompts/stack-eval.md. Pass mode (new_project | evaluate_existing | compare_frameworks) and project context. The agent evaluates against the AI-native Golden Path matrix (references/golden-path-matrix.md) — stack chosen for how accurately an LLM can implement it, not just general fit.
Validate the returned JSON before consuming (use python3, or python on Windows):
echo "$AGENT_OUTPUT" | python3 ${plugin_root}/scripts/validate-json.py \
${plugin_root}/references/subagent-prompts/stack-eval.schema.json - --extract-from-markdownRe-prompt once on schema failure, then fall back to markdown parsing. Read the result:
confidence: high|medium → present the recommendation.confidence: low → surface the risks before proceeding.escalation_required: true → stop; recommend rethinking scope via the brainstormer.A stack choice is durable. Record a brief summary in plan.md's Stack section; if the rationale is worth keeping, surface it into the update-prompt (Phase 6).
Load references/plan-template.md for the output structure, in a parallel batch with references/failure-state-template.md, references/tdd-constraints.md, references/context-management.md, and references/anti-patterns.md.
Build the release map first. Three horizons, anchored to the interview:
tasks cover, in full six-field detail.
Detail decays with distance by design — speccing distant versions in task detail is fake precision. Pulling "Next" into detail is a /rad-planner:replan event.
Decompose goal-backward within the Now horizon: what must be TRUE, what must EXIST, what is CRITICAL vs. nice-to-have, what is explicitly a non-goal. Critical items become milestones; non-goals land in plan.md's Scope.
Sequence risk-first, with size discipline.
committing effort to dependent work.
(warn, don't force — respect user agency).
Spec every task to execution-readiness. Each task carries all six fields: Objective, Files, Depends on, Done when, Validate, Rollback. Apply the failure-state triple (Action / Validation / Rollback) and insert a checkpoint after every milestone. Note where to checkpoint-and-clear context per references/context-management.md.
Write for both readers. The task fields serve the coding agent — keep them precise. The human layer serves the vibe coder: the "How to read this plan" note, the release map, and an After this ships: line under each milestone heading saying in plain English what the user can do once it lands. Both are in the template.
Write the draft. Compose the plan into docs/plan.md with **Status:** DRAFT, following references/plan-template.md. (Path resolution and existing-plan detection: see "Plan location" below.)
Mechanical validation first — run on the draft (use python3, or python on Windows):
python3 ${plugin_root}/scripts/plan-lint.py docs/plan.md --jsonIt flags missing sections (including the release map), tasks missing any of the six fields, unresolved or cyclic dependencies, and vague language. Fix every CRITICAL or HIGH issue before risk assessment — risk-assessor should spend its judgment on what scripts can't check.
Then adversarial review. Delegate to the risk-assessor agent using references/subagent-prompts/risk-assessment.md. It checks against the documented anti-patterns (references/anti-patterns.md), architecture concerns, rollback quality, and checkpoint placement. Validate its JSON (validate-json.py against risk-assessment.schema.json), re-prompt once on failure, then fall back to markdown.
On the quick path: a single risk pass (max_iterations: 1) — fix blocking issues once, present anything unresolved to the user, no loop.
On the full path, read the verdict:
APPROVE → proceed to Phase 5.REVISE (iteration < 3) → fix blocking_issues, re-lint, re-dispatch.REVISE (iteration ≥ 3, issues remain) → stop looping; surface unresolved issues andask the user to accept as known gaps, restructure, or re-enter via the brainstormer.
RETHINK → stop immediately. The architecture has fundamental issues task-leveledits won't fix. Recommend /rad-brainstormer:design-sprint.
Present, in this order:
delivers, what comes after, and the one biggest risk.
plan embeds (stack choice, ordering choice, deliberate exclusion, risk mitigation) so the user signs off on decisions, not a wall of tasks.
risk report, and plan-lint result — available, after the parts a human reviews.
Ask explicitly: "Does this match what you're trying to build? Anything to adjust before I lock it in?" The plan is not approved until the user says so. Incorporate feedback and re-lint if tasks change.
On approval:
plan.md's **Status:** DRAFT to APPROVED and stamp **Updated:**.planner doesn't own (a change to an existing PRD, a decision worth recording, an architecture implication), write docs/[date]-update-prompt.md per the update-prompt template in references/plan-template.md, and add the **Pending durable-doc updates:** pointer line to plan.md. If nothing durable surfaced, write no second file.
plan-lint.py once more on the final plan.md; report clean or surfaceremaining issues for the user to accept or fix.
The planner owns plan.md, and may birth docs/prd.md from the interview (Phase 1, per-section confirmation) when none exists. Everything else durable — changes to an existing PRD, the decision log, the architecture reference — it does not write. It records the needed change in the update-prompt as a plain-language, paste-ready instruction naming the target file, and points plan.md at it. The user (or a coding agent they run) applies it. After birth, the PRD is maintained by the user and rad-repo-manager's wrapup — the planner doesn't touch it again outside the update-prompt.
Default: docs/plan.md. Before creating, detect an existing plan — check, in order: docs/plan.md, docs/planning/current-execution.md, docs/planning/current.md, root PLAN.md. If a real plan exists and work has happened since it was written, that's a re-plan, not a fresh plan — hand off to `/rad-planner:replan`, which marks shipped work from git evidence before restructuring. Only update in place when the existing plan is a stub or no execution has started. Greenfield → create docs/plan.md. Never write outside docs/.
Batch independent reads — Phase 1 codebase exploration and Phase 3 reference loading each have no inter-file dependencies. Serialize only user-approval gates and the phase order itself.
references/discovery-interview.md — the interview protocol: coverage areas, mirror, rounds, both closing gatesreferences/plan-template.md — plan.md + update-prompt structure, enforced rulesreferences/failure-state-template.md — Action / Validation / Rollback triplesreferences/tdd-constraints.md — per-task test strategyreferences/context-management.md — checkpoint-and-clear protocolreferences/anti-patterns.md — documented planning anti-patterns (risk-assessor)references/golden-path-matrix.md — AI-native stack evaluation criteriareferences/subagent-prompts/stack-eval.md — stack-advisor dispatch templatereferences/subagent-prompts/risk-assessment.md — risk-assessor dispatch templatescripts/plan-lint.py — mechanical plan.md validatorscripts/validate-json.py — subagent JSON-contract validatorexamples/plan.md — a real, lint-clean plan~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.