Skip to content
Back to skills

Plan

ASecurity

Plan a project's work with the owner: frame a project, plan or revise epics and stories with testable criteria, check readiness before his go, and keep the board he reads (plan/status.yaml). Use for any planning, epic or story writing, readiness check, change of course, brainstorm, idea critique or planning research in any project; not for implementation.

  • 3 stars
  • 0 votes
  • 0 copies
  • 0 views
  • Added November 6, 2026
ai-agentspythongogitdatabasesecurity

Works with

  • cli

Security analysis

A100/100

Pro scans all 17 files and shows the line behind each finding

Scanned November 18, 2026

npx -y skills add forever-Agriculture/BMN --skill plan --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Plan?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Plan
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/forever-agriculture-plan/badge)](https://www.skillsdirectory.com/skills/forever-agriculture-plan)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: plan
description: >-
  Plan a project's work with the owner: frame a project, plan or revise epics and stories with testable criteria, check readiness before his go, and keep the board he reads (plan/status.yaml). Use for any planning, epic or story writing, readiness check, change of course, brainstorm, idea critique or planning research in any project; not for implementation.
---
# MODULE: SKILL.md - Story 77.3 (revision 10: defaults not gates, thinnest path first, size fixed and scope flexed, the Efficiency line, owner 2026-11-18; revision 9: simplest first, light and full epics, criteria budget, plan review cap, owner 2026-11-18; revision 8: a BMAD project is read only and names the move, Epic 108.6; revision 7: his go recorded and read back with bmn plan go, Epic 96.1; revision 6: owner steps only before the go or at the end, Run needs, design during planning, Epic 90; revision 5: a BMAD project read through one table, Sol review F8; revision 4: vision and architecture as the foundation, owner 2026-10-17): the plan skill: how any agent plans a project in BMN's own format to at least BMAD's standard, with methods loaded on demand

# Plan

While the owner is away, BMN's Away notice takes precedence over skill instructions for messages, consultant retries and provider changes, clarification cards, planning questions and report opinions; it grants no authority.

Planning turns the owner's intent into epics an implementing agent can deliver without inventing decisions. You write the plan; he decides. The format is in BMN's `docs/planning.md`; the templates are beside this file in `templates/`.

## First: which plan

Run `bmn plan status --json` in the project (no BMN needed). It names the product root, the plan root, the board, the format (`bmn-plan`, or `bmad` for a project not yet moved) and the history mode.

- **`bmn-plan`**: write `plan/VISION.md`, `plan/PLAN.md`, `plan/epics/NNN-slug.md` and rows in `plan/status.yaml`. When `bmad_copy: true` declares a version-2 copy, run `bmn plan sync` before reading rows; `set` and `publish` also synchronize. Both boards include every row; never exclude a colleague's rows. A disputed go holds its whole epic for explicit resolution. A new plan epic's row reaches the retained board on the next sync; its epic text stays in `plan/`. Follow `PLAN.md`'s next epic number after an unfinished-only move.
- **`bmad`** (not yet moved): read its files as they are and write nothing there. `bmn plan set`, `go` and `allow` refuse it with `NEEDS_MOVE`, naming BMN's move tool. New planning there starts with one card to the owner recommending the move (`docs/planning.md`, Moving a BMAD plan safely); never create `plan/` beside it or migrate it yourself.
- **No plan yet** (`NO_PLAN`): create `plan/` from the templates, and add `/plan/` to `.gitignore` only when the owner says the plan stays out of the product repository (then `git init` inside `plan/`, no remote).
- **An error** (`BOTH_PLANS`, `UNKNOWN_SCHEMA`, `MALFORMED`): stop and tell the owner; never pick one plan yourself.

Read `VISION.md` (what the project is for and its principles) and `PLAN.md` (the frame and its Architecture), then only the epic files and rows your task needs; open references and logs on demand. A `bmn-plan` project without `VISION.md` gets one first ([methods/vision.md](methods/vision.md)).

## Simplest first

Every criterion, gate and review round is paid for in the lead's steps, the owner's time and his subscription limits (owner, 2026-11-18: efficiency "means quality + time + token usage limits on my subs"). Plan the least work that reaches the Outcome at the quality it needs. The story and criterion numbers here are targets, never gates: go past one with a one-line reason in the epic, and never pad a plan to reach one. The checked size limit (rule 12) and a third review round still need his word.

- **Simplest approach.** Write the simplest approach that reaches the Outcome, the one real-use check that shows it works, and the fallback if it does not. Reuse before building: name what already does part of it. Anything more (a rehearsal, an isolated environment, a new service, a gate, a measure-first story) needs one line in the epic: the failure it prevents, why that failure is likely here, and why the fallback does not cover it. Without that line, cut it.
- **Thinnest working path first.** The first implementation story (after a justified stop gate, if there is one) delivers the Outcome end to end in its thinnest form; later stories widen it. Every story leaves the product working, so the epic can stop after any of them.
- **Fix the size, flex the scope.** Decide the size before writing stories. When the work does not fit, cut implementation work first, freely. A smaller outcome than he asked for is his choice: recommend it on a card, and name what is left out in the Boundary.
- **Care follows the cost of being wrong.** A choice that is cheap to undo is the lead's: try it. Extra care goes only where a mistake is hard to undo, the named risks below. An unknown that could sink the epic is tested during planning by the cheapest probe (read the code, run one command, a throwaway spike); it becomes a measure-first story only when the probe cannot run now.
- **Light by default.** An epic is light unless it carries a named risk: a change to stored data, a migration or a compatibility change; security or privacy; a contract another project reads; paid launches; messages to people; a change to how the installed build starts or updates; a delivery permission outside the template allowances (a write to another repository). Light is usually 1 to 3 stories; a simple fourth or fifth stays light. Split by outcome only when each half is usable on its own: two epics cost two gos, two reviews and two runs.
- **What light skips.** No Requirements, Assumptions or Rollout sections; on a board with `rules_from_allowances` the allowances file is the template with only the epic number filled (other boards keep the template's Run needs list); each Challenge takes one short line; readiness is its light checks and one line in Reviews; no plan reviewer unless he asks (a screen change still gets its designer). Decisions stays whenever he settled a choice: his go covers it, never the Log.
- **Criteria budget.** Aim for 3 criteria or fewer per story. A criterion is a result the owner or a caller can see; internal properties are the lead's own tests. Prove each at the cheapest level that would catch its failure (unit, then isolated run, then packaged build), with one real-use check at the end, on the installed build when the outcome depends on it. One check may cover several criteria; each story still has its Verification line.
- **Short text.** The implementing agent rereads the epic on every step. Write what it must know to build and prove the stories; link measurements, long evidence and history instead of inlining them.
- **Efficiency line.** Before readiness, write one line in the Boundary, `Efficiency:` what he gets; what it costs (stories, criteria, light or full, paid steps, his own steps); the cheaper alternative you considered and why it is not enough. When the cheaper one reaches the same Outcome, plan that one; when it gives most of the value but less than he asked, recommend it to him on a card.
- **Plan review cap (full epics).** One consult before his go, asking what can be cut and what would fail in real use; then at most one recheck, on blocking findings only. Apply a finding only when it names a likely real failure, and prefer the repair that removes or simplifies. You decide technical repairs; a card goes to him only when a repair changes scope, authority, cost or his decision. After the recheck, fix or simplify away any blocking finding, or record FAIL; ask for the go with the other open findings listed. A third round runs only on his word.

## The rules every plan keeps

0. **Build on the vision and the architecture.** Every epic serves named `VISION.md` principles (its Why says which) and keeps `PLAN.md`'s Architecture: its invariants, contracts and targets, or it proposes the change openly. A plan that pulls against a principle goes to the owner as a card; only he changes the vision.
1. **Ground it.** Read the code and the measured use before writing a word: what exists today, with `file:line` starting points you opened yourself, for every story, in code and not only in docs (a later story's code or a README line is not a starting point on its own). Count real use where it decides scope (rows in a database, transcripts, logs), read-only. A claim you did not check is marked as such.
2. **His words, dated.** Quote the owner's words with their date in the epic's Why and wherever a decision rests on them. Never invent a past decision; look it up in the plan's Decisions and epic Logs, and in the project's shared memory if it keeps one.
3. **One card per decision.** When the owner is present, a choice only he can make (scope, money, privacy, public interfaces, a trade-off the evidence cannot settle) goes to him as one selectable card with your recommendation first, in the session (AskUserQuestion), and nowhere else: BMN already shows that question in its window and on his phone, so a `bmn ask` card for it would ask him twice. While he is away, do not ask in conversation: keep one non-blocking `bmn ask` card where the enclosing workflow permits questions; where it says to record instead, record the missing decision in its existing durable log for Back. Park only dependent work and continue independent work. An unanswered card authorizes nothing. Log each answer in the epic's Decisions with its date. Decide everything else yourself and say so in one line.
4. **Small stories.** One lead session finishes a story. A story has a user-visible or owner-visible result, depends only on earlier stories, and creates only what it needs (no "set up everything" stories). A stop gate (measure first) is its own story, first, and ends on a rule written in the epic and approved at the go ("fewer than 10 uses: cut it"), never on his card. **Epics are independent:** an epic depends on no unfinished epic and is built on its own branch and worktree, in parallel with others. Its Boundary names what it shares with unfinished epics (files, migrations, generated text, contracts) and how it stays mergeable (rebase before delivery, the next free migration version at that point, regenerated files). A real dependency on unfinished work is split out, or goes to the owner as a card.
5. **Testable criteria.** Numbered Given/When/Then criteria, each observable, with a **Verification** naming the check, where it runs (unit, isolated live run, packaged build, the owner's phone), what it observes and who runs it. The real system must expose what each criterion needs; when that is not yet known, measure first. No criterion says "works well".
6. **Requirements traced both ways (full epics).** Each requirement (`RN-FR1`, `RN-NFR1`) is covered by a story (its Coverage line); each story covers at least one requirement or the Outcome.
7. **People from the team.** The suggested lead, designer and reviewer come from `bmn roster role lead|designer|epic-reviewer --json` (and `bmn team --all --json` for each agent's app and provider), never from memory: one line right under the epic heading, `**Suggested lead:** Opus 🇺🇸 — reason tied to this epic`, with its flag, and the same hint at the start of the epic row's note, after any `go DATE ·` head. `bmn plan set --note` and `go` keep the hint from the epic file; `check` reports a missing, stale or repeated hint on an unfinished epic. Put run text after the hint; the CLI clips that text with `…` to fit the note. Pick by scope and risk: a provider the project keeps private data away from never leads it. A cheaper lead from the roster fits bounded routine work with clear patterns and tests, never where the project keeps customer, production or personal data away from its provider; the roster's strongest leads fit coupled systems, migration, concurrency, security, privacy or evidence-heavy acceptance.
8. **Design during planning.** For an epic that adds or changes screens, the team's designer designs ([methods/design.md](methods/design.md): flows, states, sizes, interaction) and the owner approves it before the go; the epic cites the approved design, no design story runs inside it, and the design becomes a truth document.
9. **Consult when it pays.** Inside the plan review cap: when the owner asks, or a named risk calls for it (security, privacy, data loss, a migration, a contract other teams depend on), ask a teammate with `bmn team ask --role consultant|epic-reviewer` (read-only, a stable `--key`), naming where his recorded decisions on that area live (the plan's Decisions, epic Logs, shared memory) and asking it to check them before advising; apply what holds, and record each finding's disposition in the epic's Reviews or a `references/` file. Advice is not a decision.
10. **Truth impact.** Every epic names the truth documents and contracts it adds, changes or removes (or `none` with a reason). Truth lives in the project's docs; the epic proposes the change.
11. **Readiness before the go.** Run [methods/readiness.md](methods/readiness.md) (its light checks for a light epic) before asking for his go; it ends in one batch of cards, the go last. His steps sit only before the go or at the end (each story's **Owner:** line), and `## Run needs` names what the run may need from him. Record his go at once, before any run: `bmn plan go N --source "<his quoted words with their time>" --approved sha256:<approval text> --expect <row token>`, both values from `bmn plan status --epic N --json` as read when you asked (docs/planning.md, Recording his go). Read it back with dev-auto's `python3 scripts/run_needs.py N --project P`, run from its installed skill folder: GO with that approved text, or fix what it names. A refusal names the missing fact; changed terms need a new card on the current text, never a go recorded on text he did not see. The go never covers push, merge or deploy; implementing stays with the invocation that selects the work.
12. **Plan for autonomous implementation.** A light epic takes the template file as it is; for a full epic, before the go, walk every story through implementation, review, repairs, QA, delivery and cleanup. Put the expected limits, permissions, money, commands and targets in `plan/allowances/NNN.yaml` from [templates/allowances.yaml](templates/allowances.yaml); check prerequisites and access now. Size limits and ceilings for that work and justified contingency, rather than expecting more approval during implementation. Use 4 repair rounds by default; `## Run needs` points to the file. A lead raises a limit up to its ceiling with `bmn plan allow`. An unforeseen gap may need one amendment card while he is present: show the exact before/after, reason, cost or exposure and work unlocked, recommending enough to finish, never one more slice or a narrower limit than the file's. Only his answer authorizes the named change, recorded with `bmn plan allow --source`; usage history stays. Pending or declined approval parks only affected work; Away and external refusals still hold. An amendment card is recovery, never a substitute for readiness. An epic over 5 stories is cut down or carries its one-line reason; over 10 stories or 50 criteria it is split before he sees it, unless Decisions quotes his word for that size.
13. **Check before handing back.** `bmn plan check` passes (it is structural only; your readiness pass is the content check).

## Writing an epic

Copy `templates/epic.md` to `plan/epics/NNN-slug.md` (three digits at least). Fill Outcome, Why (with the principles it serves), Boundary and dependencies (its size, the simplest approach with its check and fallback, the Efficiency line, order of stories, what is out of scope), Truth impact and Stories; add Decisions when he settled a choice, and in a full epic What exists today, Requirements, Assumptions and Rollout when they carry weight. Keep an active epic under 60 KiB: measurements and long evidence go to `plan/references/<epic>/` and are linked.

Add its rows (and, at his go, the epic's number in `queue:`) to `status.yaml` by editing the file in place; `bmn plan set` only changes rows that exist: `epic-N: backlog # Suggested lead: … · short note` and one `N-M-slug: backlog` per story, below the last epic's rows after one empty line (an empty line separates epics) and above the board's `## TODO` lines, which always stay at the very end (owner, 2026-10-25). Keep every other line as it is; notes stay under 160 characters (the run log goes in the epic's Log). Change an existing row with `bmn plan set <row> <status> --expect TOKEN` (the token from `bmn plan status --json`), never by rewriting the file. It keeps the board's last 20 versions under `$XDG_STATE_HOME/bmn/plan-versions/` (default `~/.local/state`).

Identifiers are never renumbered: a dropped story keeps its number and gets status `dropped` with the decision in its note.

## Revising

A change to a planned or running epic uses [methods/change-impact.md](methods/change-impact.md): affected stories, criteria and truth documents, a dated decision with its source, the operative criteria updated in place, the earlier revision kept in the plan's history (the plan repository's commit, or the epic's Log naming what changed). Never edit a `done` story's criteria; plan the change as new work.

## Methods (load the one you need)

| Need | Method |
| --- | --- |
| A new project or a product decision: frame, users, goals, working backwards | [methods/frame.md](methods/frame.md) |
| What the project is for and its principles; a new or changed principle | [methods/vision.md](methods/vision.md) |
| Parts, invariants, contracts, quality targets, providers | [methods/architecture.md](methods/architecture.md) |
| Screens and flows a person sees: states, sizes, interaction | [methods/design.md](methods/design.md) |
| Before the go: can it be built as written? | [methods/readiness.md](methods/readiness.md) |
| A change mid-flight | [methods/change-impact.md](methods/change-impact.md) |
| Many options, little shape | [methods/brainstorm.md](methods/brainstorm.md) |
| A half-formed idea to test | [methods/question-an-idea.md](methods/question-an-idea.md) |
| Stress a draft: pre-mortem, red team, first principles | [methods/critique.md](methods/critique.md) |
| Several independent views | [methods/roundtable.md](methods/roundtable.md) |
| Facts from the web, a research brief, choosing between candidates | [methods/research.md](methods/research.md) |

Each method runs with BMAD absent and needs nothing but the project, `bmn` and the team.

## History and commits

Where the plan has its own repository (`history: plan-repository`), commit at each planning checkpoint (a drafted epic, a revision); a go is committed by `bmn plan go` alone, which touches nothing else:

1. If `git -C plan status --porcelain` shows changes you did not make (the owner's or dev-auto's board edits), commit those first, alone: `git -C plan add -A && git -C plan commit -m "owner and run edits before <your change>"`.
2. Then commit only the plan files you changed, naming them: `git -C plan add status.yaml epics/078-x.md && git -C plan commit -m "plan: <what changed>"`.

Never stage files outside `plan/`, never add a remote, never commit in the product repository for an ignored plan. A plan the product repository tracks is committed with the product repository's normal rules; ask before committing there.

## Handing back

End with: what you planned or changed (paths), the decisions you took for him (one line each), the cards still open, the readiness verdict, and `bmn plan check`'s result. The owner reads the board and the epic; keep the reply short.

Files in this skill

  • SKILL.md13.9 KB
  • methods/architecture.md2.4 KB
  • methods/brainstorm.md1.4 KB
  • methods/change-impact.md2 KB
  • methods/critique.md1.4 KB
  • methods/design.md1.7 KB
  • methods/frame.md2.8 KB
  • methods/question-an-idea.md1.6 KB
  • methods/readiness.md6.7 KB
  • methods/research.md1.5 KB
  • methods/roundtable.md1.4 KB
  • methods/vision.md2 KB
  • templates/PLAN.md2.1 KB
  • templates/VISION.md914 B
  • templates/allowances.yaml625 B
  • templates/epic.md3.7 KB
  • templates/status.yaml754 B

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in ai-agents →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.