fanout-features

name	fanout-features
description	Take a list of feature ideas for the Campfire seed app (one per line, free-form text), read the actual card files under app/src/cards/ and app/src/theme.css, infer which file(s) each feature would touch, group the features into PARALLEL-SAFE BATCHES so no two features in the same batch edit the same file, and emit one ready-to-paste prompt per batch (with the target file scoped explicitly). Returns a markdown plan a human can dispatch across split Copilot panes without merge conflicts. Use this when an agent or user has a pile of feature ideas they want to run in parallel — e.g. straight from notepad in the Inner Loop / Fast Parallelism exercise. Does NOT execute any of the features; it only plans the fan-out.
user-invocable	true

Fanout features

You are in fanout-features mode. Your job is to turn a pile of feature ideas into a parallel-safe dispatch plan for the Campfire app, so the human can paste one prompt per Copilot pane and walk away.

Step 1 — Read the actual app structure

view and glob your way through:

• app/src/main.ts — to see how cards are registered.
• app/src/cards/ — every file here is a card module.
• app/src/theme.css — the first-class home for design tokens, palettes, shadows, and theme-only changes.
• app/src/style.css — shared component CSS.

If app/src/cards/ doesn't exist, stop and tell the caller — this skill is specific to the seed app's layout.

Step 2 — Parse the input

The caller will paste a list. Each non-empty, non-# line is one feature. The format is free-form prose; you don't need to parse fields. Drop lines starting with # (those are comments).

Step 3 — Infer the target file(s) for each feature

For each feature, decide which file(s) it would touch. Use these heuristics:

Feature mentions…	Likely target
gear / packing / checklist	app/src/cards/gear-checklist.ts
trail log / hike / miles / activities	app/src/cards/trail-log.ts
prompt / journaling / question of the day	app/src/cards/todays-prompt.ts
weather / forecast / temperature	app/src/cards/trail-weather.ts
welcome / greeting / camper name	app/src/cards/welcome.ts
palette / colors / typography / theme / vibe	app/src/theme.css
dark mode / theme toggle / color mode	app/src/theme.css + the file with the toggle UI
layout / spacing / shadow / responsive	app/src/style.css
add a new card	new file in app/src/cards/ + app/src/main.ts
persist anything across reload	the relevant card file (no shared state file)
connect to an external API	the relevant card file

If a feature is ambiguous, write your best guess and add a 🤔 to its line in the output. If a feature would clearly touch >1 file, list them all — that feature is a single-batch single-pane item.

Step 4 — Pack into parallel-safe batches

A batch is a set of features whose target files are pairwise disjoint (no file appears in two features within the same batch).

• Use a greedy first-fit pack: walk features in input order, drop each into the lowest-numbered batch where its files don't overlap with anything already there.
• Aim for batches of 2–4. Anything beyond 4 is hard for a human to dispatch in one pass.
• A feature that touches app/src/main.ts is shared infrastructure — only one such feature per batch.

Step 5 — Stylist routing

If any feature is purely visual (palette, type, spacing, "warmer" / "calmer" / "make it pop", before-after critique), prefix its prompt with @stylist so the auto-orchestrator routes it to the Stylist advisory agent rather than a generic executor.

Stylist prompts go in their own batch — Stylist returns advice the human reviews + applies, so it doesn't conflict with concurrent executor work on the same file. A Stylist proposal for theme.css is safe to run alongside an executor working on cards/gear-checklist.ts.

Step 6 — Emit the plan

Return only this block, nothing else:

## Fanout plan — <N> features across <M> files

### Batch 1 — paste one per pane, run in parallel

- **[pane A]** `<file the agent should focus on>`
  > <ready-to-paste prompt, ending with "Only edit <file>.">

- **[pane B]** `<file>`
  > <prompt>

- **[pane C]** `<file>`
  > <prompt>

### Batch 2 — run after Batch 1 lands

- **[pane A]** `<file>`
  > <prompt>

- **[pane B]** `<file>`
  > <prompt>

### Skipped / needs clarification

- 🤔 <feature line, verbatim>
  > <one sentence on why — ambiguous target, touches too many files, conflicts
  >  with a feature already in flight, etc.>

The prompt for each pane MUST end with "Only edit <exact file path>." (or "Only edit <file> and register it in app/src/main.ts." if it's a new card). That single sentence is what keeps two autopilot agents from stomping each other.

Output contract

Return only the markdown above. No preamble, no "Here's the plan", no closing remarks. The caller will paste your output into their notepad and dispatch from there.

Boundaries

• Don't execute the features. This skill plans only. Editing is the calling agent's (or Stylist's) job.

• Don't invent files. If your target file doesn't exist, glob for the real one before naming it in the prompt.

• Don't merge unrelated features. Each input line is one feature; don't "combine" them.

• If the input is empty or all comments, respond with exactly:

  No features to fan out. Paste a list (one per line) and try again.