Brainstorming swarm: design under parallel pressure

Solo brainstorm works when one seat and one human can hold the problem. Build swarm works when the design is already locked and you need hands on the code. This pack sits in the middle: many seats on the design itself, then a hard stop before anyone builds.

It is a skill you load into an agent workspace. Markdown, schemas, role cards. No vendor runtime. No cloud dispatch product. Any capable seat that can follow files can run a role.

What it does

You point the skill at a hard design problem. The conductor frames the goal and hard locks. Discovery lenses fan out (failure, stakeholder, constraint, temporal, experiential by default). You hold Gate A. Competing approaches fan under different axioms. Critique kills, keeps, or salvages. You hold Gate B. The swarm presents a design, writes the approved version, and halts.

That last word matters. This skill does not build. Terminal outcome is a written design you can defend. Implementation is a different job, a different session, and usually a different pack.

+--------+     +-----------+     +--------+     +------------+
|  S0    | --> |  S1       | --> | Gate A | --> |  S2        |
| Frame  |     | Discovery |     | human  |     | Approaches |
+--------+     +-----------+     +--------+     +------------+
                                                      |
                                                      v
+--------+     +-----------+     +--------+     +------------+
|  S5    | <-- |  S4       | <-- | Gate B | <-- |  S3        |
| Spec   |     | Present   |     | human  |     | Critique   |
| HALT   |     +-----------+     +--------+     +------------+
+--------+

Brief in, digest out. Each parallel leg gets a scoped brief: goal, locks, schema, word caps. The conductor gets named fields back, not a raw tool stream. Invalid or dump-shaped returns get rejected once, then escalated to you.

  DUMP (rejected)              DIGEST (accepted)
  ----------------             -----------------
  full tool logs               named fields only
  recursive tree paste         hard word caps
  "here's everything I saw"    one retry on bad shape
  floods the window            protects the window

Mode honesty. Label the run for what actually happened:

Mode	Meaning
dispatch	Independent seats ran the legs
serial_fallback	One seat played roles in sequence; schemas still hold
partial	Some parallel, some serial; name which

Never claim peer critique when one seat performed every role. Floor success without multi-seat is required. Floor is not the default.

Thought process

Three load-bearing ideas shaped the pack. None of them are product marketing. They are scars from long sessions that drowned.

Context is scarce

Tokens spent on logs, bulk reads, and tool streams do not come back as clarity. The main chat is a scarce surface. If every leg dumps its research into that surface, the conductor stops thinking and starts scavenging.

So the unit of exchange is the digest. Schema-capped. Field-named. Rejectable. The swarm can be loud at the edges and quiet in the middle.

Orchestrator is not the doer

The main seat advises, routes, synthesizes, and holds gates. Heavy work leaves the seat. Workers execute. They do not advise you, rewrite process, or own taste and route choices.

That split is the same idea as renting a conductor and swapping the orchestra: expensive judgment stays central; parallel labour fans out. Here the labour is design pressure, not implementation.

Aggressive dispatch

Default to fan-out when multi-seat exists. Keep work inline only when it is small and local. Ask: will this flood my window?

Flood triggers include large output, large read sets, long focused execution, isolation needs (parallel design legs that must not share mid-work state), and capability mismatch. When in doubt and multi-seat is available, fan out.

  DISPATCH-FIRST (default)          SERIAL FALLBACK (floor)
  ------------------------          -----------------------
  multi-seat / multi-tab            one seat, stages in order
  same-turn spawn when ready        same digests, same gates
  true peer critique possible       mode: serial_fallback
  mode: dispatch                    never fake peer quality

Serial success is required for LLM-agnostic honesty. Serial-as-default doctrine is rejected. Dispatch-first is the practice whenever parallel capacity exists.

Sibling triangle

Three related skills. Pick by job, not by habit.

                 +----------------------+
                 |  brainstorming swarm |
                 |  many seats on DESIGN|
                 |  stop at written spec|
                 +----------+-----------+
                            |
           +----------------+----------------+
           |                                 |
           v                                 v
  +------------------+              +------------------+
  | solo brainstorm  |              | build swarm      |
  | one seat, design |              | many seats on    |
  | until approval   |              | IMPLEMENTATION   |
  +------------------+              +------------------+

If one seat and one pass is enough, use solo brainstorm. If design is already locked and you need implementation fan-out, use build swarm. This pack is the middle of that triangle: parallel pressure on the design itself.

How I made it

I already had a solo brainstorm discipline: one question at a time, a hard gate before code, a written design as the terminal state. That skill stops the agent from building the wrong thing with confidence. It does not give you competing frames under time pressure.

What I needed next was the design equivalent of a build fan-out. Multiple lenses on the same goal. Competing approaches that do not leak into each other mid-flight. Critique that can kill a frame without killing the whole chat. Digests that keep the conductor window readable.

So the pack is protocol-shaped, not product-shaped:

• Stages and hard gates so the run has a spine and humans stay in the loop at Gate A and Gate B
• Roles (conduct, gather, draft, judge, synth) so cards are portable across harnesses
• Lenses and axioms as replaceable cards, not hard-coded opinions about your domain
• Digest schemas with word caps so workers cannot flood the seat
• Fan-out doctrine with an honest serial fallback so the method still works on a single tab

Everything is plain markdown. Drop the tree into a skills directory. Invoke it. No package manager. No telemetry. No vendor lock as the spine.

Member distribution is deliberate: community members on aris.space get the versioned zip. You load it, run it, and keep the design artefact in your repo. The site is the front door. The skill is the method.

How to use it

1. Get the pack

Members download the zip from the CTA at the bottom of this page (or from the community skill surface once your seat is live). Unzip and place the brainstorming-swarm folder where your agent loads skills.

2. Invoke

Point a capable seat at the skill and the problem:

Read SKILL.md and run brainstorming-swarm on: <goal>.
Prefer dispatch-first. Use serial fallback only if multi-seat is impossible.
Stop at a written design. Do not build.

3. Run the stages

1. S0 Frame the goal and hard locks. Bound the context. Digests only if the read set is large.
2. S1 Fan discovery lenses. Collect digests. Compress a short summary for yourself.
3. Gate A Redirect or approve before approaches start. Do not skip this.
4. S2 Fan competing approaches under different axioms (defaults: mvp-first, risk-first, portability-first).
5. S3 Critique. Kill, keep, or salvage per approach.
6. Gate B Pick a winner or hybrid. That choice is yours.
7. S4 Present the design for approval.
8. S5 Write the approved design. Halt. Do not start implementation from this skill.

4. Hand off

The written design is the contract for whatever comes next. A build session, a build swarm, or a quiet week of solo coding. Continuity tools (for example Save For Later) can hold decisions and rejections around that design. They do not replace the gate.

When not to use it

• One seat, one pass, small problem: solo brainstorm is enough.
• Design already locked: go straight to build work or a build swarm.
• You want the agent to start coding "while we think": stop. That is the bug this family of skills exists to prevent.

Get the skill pack