Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

brainstorming

/brainstorming

Wyjaśnia cel użytkownika, porównuje dwa lub trzy podejścia oparte na kodzie i zatwierdza projekt przed kodowaniem.

Repozytorium
legion ↗
Licencja
MIT
Ostatnia zmiana repozytorium
12.11.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
6
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 12.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Wyjaśnia cel użytkownika, porównuje dwa lub trzy podejścia oparte na kodzie i zatwierdza projekt przed kodowaniem.

Wyzwalacze z opisu

add Xhelp me shape Ynot sure of the details yetwhat are my optionswhich would you pick
Oryginalny opis (EN)

Draws out what the user wants and why, compares two or three approaches grounded in the code, grills open decisions in rounds, and gets a design doc approved before any code is written. Use before building or changing anything whose intent is not settled: a new feature, component, page, CLI, flow, or behavior change, even when phrased only as "add X", "help me shape Y", or "not sure of the details yet", or when the user already explained what and why and only wants options, approaches, or a recommendation ("what are my options", "which would you pick"), even when an existing helper looks like

Jak działa

  1. Thinking rules
  2. Workflow
  3. The approval gate
  4. Gotchas
Sekcje z nagłówków SKILL.md, w oryginale · 119 linii, 1 126 słów
Podgląd SKILL.md
---
name: brainstorming
description: >-
  Draws out what the user wants and why, compares two or three approaches
  grounded in the code, grills open decisions in rounds, and gets a design
  doc approved before any code is written. Use before building or
  changing anything whose intent is not settled: a new feature, component,
  page, CLI, flow, or behavior change, even when phrased only as "add X",
  "help me shape Y", or "not sure of the details yet", or when the user
  already explained what and why and only wants options, approaches, or a
  recommendation ("what are my options", "which would you pick"), even when
  an existing helper looks like the obvious fit; also when asked to "grill me", poke holes in or stress-test
  a plan, decision, or idea, think it through from first principles or with
  six thinking hats, or record an ADR under docs/adr/; and when terminology is
  fuzzy or contested (one word for two concepts, two words for one) or a
  definition belongs in GLOSSARY.md.
license: MIT
metadata:
  author: ongtungduong
---

# Brainstorming

Find out what the user wants and why, then run two methods: a **comparison of
approaches** to choose one, and **grilling** to settle every decision the
chosen approach leaves open. The result is a design doc the user approves. Your belief about what they want
is usually thinner than it feels; once you know the why, you make the hundred
unstated decisions the way they would.

## Thinking rules

Four rules change what you ask and recommend; apply them inside the methods,
not as extra passes. Each stops where it no longer changes what gets built.

- Every question traces to a goal or constraint; a "given" nothing forces gets
  "what forces this?"
- Every recommendation carries "Wrong if": the fact that would flip it.
- Each answer adds the branches it sets off elsewhere.
- Ask the highest-leverage decisions first, default the ones that would not
  change what gets built, and let the same cut set the scope in step 6.

## Workflow

1. **Pick the entry.** If the user only wants an existing plan, decision, or
   idea stress-tested ("grill me on this"), run the grilling procedure in
   [references/grilling.md](references/grilling.md) on it and stop at the
   confirmed playback; a design doc follows only if something is to be built.
   If the user only wants a decision already made recorded ("record an ADR
   for X"), read [references/adr-format.md](references/adr-format.md), write
   it, and stop. If the user only wants terms pinned down ("account or
   customer?", "add X to GLOSSARY.md"), read
   [references/glossary-format.md](references/glossary-format.md), settle and
   record them, and stop. Otherwise continue with step 2.
2. **Decide whether this applies.** If everything that matters is in the
   request ("rename the flag to `--dry-run`"), skip this skill: do it and say
   what you did. A user who explained what and why but not how still gets
   steps 6 to 11: skip only the questions they already answered.
3. **Read before asking.** Read whatever the user pointed at, the code the
   change touches, and `GLOSSARY.md`/ADRs in that area, until you can explain
   how it works today. What you read is fact for the comparison. Never ask what
   the project already answers or reopen what the user already decided.
4. **Draw out intent, one question per message**, in the user's words. Until you
   know the why, ask open questions with no options attached. After that,
   propose concretely with your reason instead of asking. Ground to cover:
   intent and why now, who it is for, goals/non-goals/anti-goals, what exists
   and what was tried.
5. **Play back each part** in a short paragraph as soon as you understand it,
   marking what you filled in as your proposal, and ask what is wrong.
6. **Size the work and cut the scope.** Say the size; it sets the
   depth of steps 7 and 8 (table below). Then find the smallest part of the
   scope that delivers most of the goal and propose the rest as non-goals or
   a later step; the user decides. Several independent projects: agree an
   order and brainstorm one at a time. If it grows mid-task, step up a size.
7. **Choose the approach**, in a message of its own. Lay out two or three
   real alternatives grounded in the existing code, give the trade-offs of
   each, recommend one, and say what fact would flip the recommendation. If
   only one approach is sensible, say why the others fail. When the user asks
   for the Six Thinking Hats, read
   [references/six-thinking-hats.md](references/six-thinking-hats.md) and
   run its procedure instead; fill its table into the design doc's
   Approaches section.
8. **Grill the design.** Once the user picks an approach, read
   [references/grilling.md](references/grilling.md) and resolve the remaining
   design tree in rounds until the frontier is empty. Switch to it earlier, at
   any step, when three or more decisions are open at once or the user says
   "grill me".
9. **Write the design doc.** Copy [assets/design-doc-template.md](assets/design-doc-template.md)
   to `.legion/specs/YYYY-MM-DD-<topic>-design.md` (unless the repo or
   user prefers another place) and fill it, including the approach comparison
   and the grilled decisions. Offer an ADR for the chosen approach or a grilled
   decision only when all three hold: hard to reverse, surprising without
   context, and the result of a real trade-off. Before writing one, read
   [references/adr-format.md](references/adr-format.md).
10. **Builder check (projects only).** Re-read the doc as a builder who must
    plan from it, or dispatch a fresh, read-only `general-purpose` subagent
    on `model: "sonnet"` to do it. Answer what the
    conversation already settled, settle minor gaps yourself and mark them as
    your calls, and bring only the real decisions to the user in one message.
11. **Get approval, then** call the Skill tool with `legion:writing-plans`.

| Size | Design doc | Approaches | Grilling |
|---|---|---|---|
| Small change | Short: a line or two per section | One line of trade-offs per approach | Only if the user asks or 3+ decisions are open; "Wrong if" on each recommendation |
| Project | Full | Full trade-offs for each approach | Rounds until the frontier is empty |

## The approval gate

Nothing gets built until the user approves the design doc, short or full.
Building includes product code, scaffolding, installing dependencies, and
starting an implementation skill; reading and exploring are fine. The reason:
code built on a misread intent is the most expensive mistake to undo, and once
code exists the conversation anchors on it.

Two exits: the user opts out ("just build it"), in which case state any
significant how-it-gets-made choice in one line and proceed; or a throwaway
spike the user agreed to.

## Gotchas

- "Sounds good" to an idea is not approval of a doc the user has not seen.
- Specs handed over by users are usually incomplete; confirm before building
  on one.
- Offering a menu before you know the why steers the user toward your guesses.
- A default you chose silently is one the user could not reject. Say each one.
- Question what the request assumes, not what the system already guarantees:
  existing code, data, and contracts are facts, and reusing them is often the
  best answer.
- A scope cut the user did not agree to is a silently dropped requirement.
  Propose it; keep the scope until they say yes. The same holds for a grilling
  decision you defaulted: it goes in the playback.
- Grilling questions are decisions for the user; facts you can look up are
  yours to find before the round.
- Most decisions do not need an ADR. One that fails any of the three tests is
  noise that buries the ones that matter.
- A spike that works is still throwaway. Keeping it is a new request that comes
  back through this skill.
- Process choices (where files go, what to read, how to show something) are
  yours. Decide and say so; do not ask.
Pliki w paczce (6)
  • SKILL.md 8 KB
  • assets/design-doc-template.md 1 KB
  • references/adr-format.md 1 KB
  • references/glossary-format.md 2 KB
  • references/grilling.md 3 KB
  • references/six-thinking-hats.md 6 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · ongtungduong/legion90MIT
jjuraszek/pi-gauntlet100MIT
GanyuanRan/Aegis100MIT
Montinou/triqual100MIT
guanyang/antigravity-skills100MIT
osmontero/opencode-skills100MIT
Sanit-mann/The-Insectoids100MIT
coco-research/coco100MIT
ILIV007/prime-skill100MIT

Migawka bazy z 13.11.2026 · wersja paczki 89b68e702942 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100requirements-and-design
    Ustala potrzeby użytkownika przed budową nowej funkcji, porównuje podejścia i zdobywa zatwierdzony projekt przed pisaniem kodu.
  • 100shape
    Porównuje wykonalne podejścia do implementacji, gdy cel i fakty z kodu są już ustalone.
  • 90design
    Zbiera opcje projektowe dla funkcji, porównuje podejścia implementacji i zapisuje wynik w dokumencie projektowym.
  • 90compare-options
    Porównuje podejścia, biblioteki i wzorce w macierzy, sprawdzając istniejące użycie w kodzie i wcześniejsze doświadczenia.
  • 100design
    Przedstawia dwa, trzy podejścia do decyzji architektonicznych przed planowaniem, aby użytkownik wybrał jedno dla zaprojektowanej w burzy mózgów funkcji.
  • 100workflow-brainstorming
    Pomaga zbadać intencje użytkownika i możliwe podejścia przed planowaniem funkcji, gdy wymaganie ma kilka interpretacji.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.