Brainstorm

A pipeline request type for exploration. A brainstorm job pressure-tests a mandate, generates and weighs approaches, and converges on a recommended direction — all as a written report. It writes no source code and legitimately reaches 4_done/ on its brainstorm artifacts alone.

All request types

Of the staged lifecycle, a brainstorm job runs only the front two stages — clarify then brainstorm — and skips everything from plan through validate. The registry at _processes/_shared/request-types.md is the source of truth for this type; the preset at _processes/_shared/presets/brainstorm.md seeds its JOB.md.

The flow

A brainstorm job follows the same Kanban queues as any pipeline job, but its staged lifecycle is deliberately short. The orchestrator dispatches clarify (pressure-test the mandate, propose a normalized Mandate body), then brainstorm (generate and converge on approaches). With plan through validate all disabled in the preset, the orchestrator skips them and lands the job in 4_done/.

Brainstorm modes

The brainstorm stage itself runs in one of two modes, set by JOB.md → Per-stage config → Brainstorm → Mode. The preset default is dual_consolidate; override to solo when a single writer is enough.

solo

One brainstorm writer runs. It produces a single per-agent file — 02_brainstorm/claude.md if Agents: claude, or 02_brainstorm/codex.md if Agents: codex. No consolidate sub-step runs, and there is no consolidated.md. That single file is the brainstorm-stage artifact.

dual_consolidate

Two writers (claude and codex) each brainstorm independently — neither sees the other's output, which is what keeps their thinking divergent. They are launched together in one batch and run simultaneously, producing 02_brainstorm/claude.md and 02_brainstorm/codex.md. A consolidate sub-step then reconciles both into 02_brainstorm/consolidated.md, relaying any genuinely contested decision back to you through the orchestrator.

In dual_consolidate, the consolidator runtime is chosen by JOB.md → Per-stage config → Brainstorm → Consolidator (claude by default, or codex for a more structured synthesis style). The writer prompts live at _processes/04_brainstorm/claude.prompt.md and _processes/04_brainstorm/codex.prompt.md; the synthesiser is _processes/04_brainstorm/consolidate.prompt.md.

What it is for

Use brainstorm when the question is the work — when you need to explore a design space and converge on an approach before committing to building anything. It is the right type when the answer to "how should we do this?" is genuinely open and worth deliberating, not when the path is already clear.

Explore, then converge. The brainstorm stage produces a deliberate set of candidate approaches and lands on a recommended direction with the trade-offs spelled out.
Report-only — no code. Nothing in the source tree is touched. The artifacts are markdown brainstorm documents under 02_brainstorm/.
Reaches 4_done/ on its own. A brainstorm job is a first-class flow (D-7): once the brainstorm artifacts exist, the orchestrator moves the folder straight to 4_done/. There is no plan, execute, test, document, review, or validate.
A natural precursor to building. When you are ready to act on the recommendation, extend the same job into plan / execute (see How to run it) — the brainstorm output feeds the planner directly.

The logic

brainstorm sits in the pipeline layer with the pipeline shape — it runs the orchestrator-driven staged lifecycle, just with most stages disabled. Routing is by Type via the registry; once routed, the orchestrator dispatches the enabled stages in order and skips the rest.

Report-only, no plan/execute. Because plan, execute, test, document, review, and validate are all disabled, nothing is ever written to the source tree. The job's deliverable is the brainstorm document set, and the orchestrator moves the folder to 4_done/ as soon as the brainstorm stage's artifacts are verified.
The after_brainstorm gate. Like every pipeline type, brainstorm can pause for your sign-off. The relevant approval gate here is after_brainstorm — set it to yes in JOB.md → Approval gates to have the orchestrator stop and surface the converged result for review before landing the job. The preset ships it no.
Mode / Agents / Consolidator drive the brainstorm stage. The per-stage Brainstorm config decides whether one writer runs (solo) or two writers plus a consolidate sub-step run (dual_consolidate), which runtimes write (Agents), and which runtime synthesises (Consolidator, dual_consolidate only). The orchestrator verifies exactly the artifacts the chosen mode produces — listing a consolidated.md for a solo job would false-block, so the mode and the expected-artifacts list must agree.
Writer independence is preserved. In dual_consolidate, the two writers know the pipeline and the other roles but never receive each other's concurrent brainstorm — that cognitive independence is what makes the dual-writer split produce divergent options.

The fields

These are the JOB.md fields a brainstorm job carries, grounded in the brainstorm preset. The intake form shows the identity, mandate, stage-config, approval-gates, and git sections for this type.

brainstorm `JOB.md` fields (source: `_processes/_shared/presets/brainstorm.md`)
Field	Default	Notes
`## Git`
Create branch	`no`	No code is written, so no branch is needed.
Validate against main	`no`	Report-only.
Commit	`no`	Nothing to commit.
Push	`no`	Nothing to publish — the job ends at a report.
PR	`no`	Nothing to merge.
PR target branch	(blank)	No PR by default; blank resolves to `production` if PR is enabled.
`## Stages`
clarify	enabled	Pressure-test the mandate, propose a normalized Mandate body.
brainstorm	enabled	Generate and converge on approaches (see per-stage config below).
plan	`disabled`	Skipped — report-only flow.
execute	`disabled`	Skipped — no code written.
test	`disabled`	Skipped.
document	`disabled`	Skipped.
review	`disabled`	Skipped.
validate	`disabled`	Skipped.
`## Approval gates`
after_creation	`no`	Pause in `1_creation/` before running.
after_clarify	`no`	Pause after the clarify stage.
after_brainstorm	`no`	Pause after the brainstorm stage — the natural review point for this type.
before_plan / before_execution	`no`	Inert here (those stages are disabled).
before_commit	`no`	Git gate; renders inside the Git section.
before_pr	`no`	Git gate; renders inside the Git section.
`### Brainstorm` (per-stage config)
Mode	`dual_consolidate`	`none` \| `solo` \| `dual_consolidate`. Override to `solo` if a single writer is enough.
Agents	`claude, codex`	The writers that run. For `solo`, name the single writer (`claude` or `codex`).
Consolidator	`claude`	`dual_consolidate` only — the runtime that runs `consolidate.prompt.md`. Ignored in `solo` / `none`.

How to run it

Drop a brainstorm intake into jobs/0_new/ (set Type: brainstorm via the intake form), then send the orchestrator prompt to a fresh coding-agent session. It picks up the job, runs the creation/bootstrap step, dispatches clarify then brainstorm, and lands the folder in 4_done/.

Copy this path

_processes/02_orchestrator/orchestrator.prompt.md

Later, when you want to act on the recommendation, extend the same job into plan / execute: send _processes/_operations/extend/extend.prompt.md to a fresh session. The extend agent adds the new stages, moves the folder back to 2_ready/, and the next orchestrator run skips the already-complete brainstorm stage via PROGRESS.md.