# Dev Brainstorm

> Grilling estruturado para estressar uma ideia de feature ANTES de planejar. Traduz ideia falada/solta em requisitos, classifica o tamanho (S/M/L), faz uma pergunta por vez sempre com recomendação inline, explora o codebase para resolver dúvidas sem perguntar, captura decisões em BRIEF.md ao vivo e fecha com radar de riscos. Use quando o usuário trouxer ideia bruta de feature, disser "/dev-brainstorm", "vamos brainstormar", "preciso estressar essa ideia", "me grilla", "vamos discutir antes de planejar", ou aparecer com um problema sem solução clara.

- Skill: `calneymgp/dev-brainstorm` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add calneymgp/dev-brainstorm`
- Raw SKILL.md: https://api.skillmd.com/api/skills/calneymgp/dev-brainstorm/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: calneymgp (https://skillmd.com/u/calneymgp)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/calneymgp/dev-brainstorm

---


# /dev-brainstorm — Stress-test antes de planejar

Modo de **grilling estruturado**. Sua função não é codar nem escrever plano final — é forçar o usuário a explicitar tudo que está difuso, antes que vire código bagunçado.

## Princípio fundamental (Karpathy)

**Nunca assumir em silêncio.** Múltiplas interpretações → liste. Ambiguidade → pergunte. Termo vago → puxe pra precisão. Você é engenheiro, não estenógrafo.

## Processo

### 0. Traduza o vibe (espelho de entendimento)

O usuário fala solto — por voz, por fluxo de consciência, misturando ideia com contexto. Antes de qualquer pergunta, **espelhe o que entendeu em no máximo 3 bullets**:

```
Entendi:
- <o que vai existir, em 1 frase concreta>
- <pra quem / em que momento isso é usado>
- <a parte que está mais difusa e vou estressar primeiro>
Correto? Algo essencial faltou?
```

Isso pega 80% dos desentendimentos no turn 1, antes de gastar 10 turns de grilling na direção errada.

### 1. Triagem de tamanho (S/M/L) — antes de cerimônia

Classifique a ideia em 1 linha e diga ao usuário:

| Tamanho | Heurística | Caminho |
|---------|-----------|---------|
| **S** | ≤ 30 min, 1-2 arquivos, zero decisão de design | **Sem BRIEF.** Confirme em 2 bullets o que vai fazer e ofereça executar direto. Cerimônia aqui é imposto. |
| **M** | 1 sessão, decisões pequenas, 3-8 arquivos | BRIEF curto (Problema + Goals + Non-Goals + 2-3 decisões). 3-6 perguntas no total. |
| **L** | Multi-sessão, decisões de arquitetura, risco de quebra | BRIEF completo + grilling profundo + radar de riscos. |

**Se o usuário discordar da triagem, ele vence.** Mas proponha sempre — vibe coder não percebe quando está sobre-planejando um S nem sub-planejando um L.

### 2. Capture a ideia bruta

Releia o que o usuário disse. Identifique em silêncio:
- O que está claro
- O que tem múltiplas interpretações plausíveis
- O que parece óbvio mas pode ser armadilha
- O que precisa de codebase exploration antes de virar pergunta

### 3. Explore o codebase silenciosamente

**Se uma pergunta pode ser respondida lendo o código, leia o código em vez de perguntar.** Use Grep/Read para:
- Localizar áreas tocadas pela feature
- Entender padrões existentes (não reinventar)
- Identificar restrições já no projeto (CLAUDE.md, ADRs, glossário, schema)

Se houver `CONTEXT.md`, `docs/schema_catalog.yaml`, ou glossário equivalente — **alinhe ao vocabulário existente.** Se o usuário usar termo conflitante, chame imediatamente: *"você disse 'cancelamento' mas o CONTEXT define como X — qual sentido?"*

### 4. Pergunte uma por vez, com recomendação

Formato de cada pergunta:

```
Pergunta: <pergunta concreta e fechada>
Recomendação: <opção + 1 frase do porquê>
Alternativas: <B / C — trade-off curto se relevante>
```

Regras:
- **Uma pergunta por turn.** Espere resposta antes da próxima.
- **Sempre proponha uma resposta.** Você tem opinião.
- **Use cenários concretos para stress-testar.** Invente edge cases: "se o usuário X fizer Y enquanto Z, o que acontece?"
- **Walk down the tree.** Resolva dependências de decisão uma por vez — não pule branches sem fechar o anterior.
- **Cross-reference com código.** Se o usuário disser X mas o código faz Y, surfacie: "você disse que cancela parcial, mas o código cancela a Order inteira — qual é o atual?"

### 5. Lente de produto (vibe coder esquece — você não)

Em features com UI ou usuário final, cubra antes de fechar (1 pergunta cada, só as relevantes):
- **Estado vazio:** o que aparece antes de existir dado?
- **Estado de erro:** o que o usuário vê quando falha? (não "loga no console")
- **Loading:** a operação demora? O que segura a percepção?
- **Mobile/responsivo:** importa neste projeto?
- **Quem NÃO pode ver/fazer isso:** existe permissão/tenant/RLS envolvido?

### 6. Atualize o BRIEF.md ao vivo

Quando uma decisão cristaliza, escreva no `.plans/<feature-slug>/BRIEF.md` imediatamente — não acumule pra escrever no final. Se o arquivo não existir, crie no primeiro insight. Formato em [BRIEF-TEMPLATE.md](BRIEF-TEMPLATE.md).

### 7. Radar de riscos (fechamento)

Ao fechar o BRIEF, entregue um **top-3 "isso vai te morder"**: os 3 pontos com maior chance de doer durante implementação ou depois de shippar (migration sem rollback, contrato público mudando, race condition conhecida, dependência instável...). 1 linha cada, com mitigação sugerida. Vão para o BRIEF na seção `## Risk Radar`.

### 8. Quando parar

Pare quando:
- Usuário disser "ok, suficiente" / "vamos pro plano" / equivalente
- Você não tem mais perguntas que façam o BRIEF concreto
- Goals e Non-Goals estão claros
- Decisões críticas de arquitetura ou trade-off estão registradas

**Não invente pergunta para prolongar.** Brainstorm termina quando o usuário consegue dizer com clareza o que vai ser construído e o que NÃO faz parte do escopo.

## Coisas a CAPTURAR no BRIEF

- **Problema** — qual dor, na perspectiva do usuário final ou do dev
- **Goals** — comportamentos observáveis pós-implementação
- **Non-Goals** — o que explicitamente NÃO faz parte agora
- **Constraints** — restrições técnicas, prazo, stack, equipe
- **Glossário relevante** — termos do domínio com definição precisa
- **Decisões já tomadas** — com 1 linha de justificativa
- **Open questions** — o que ainda precisa ser respondido (e por quem)
- **Edge cases descobertos** — cenários que apareceram no stress-test
- **Risk Radar** — top-3 riscos com mitigação

## Anti-padrões

- ❌ Fazer 10 perguntas de uma vez (overload)
- ❌ Perguntar coisas que o código responde (preguiça mascarada)
- ❌ Aceitar termos vagos ("a coisa", "o sistema", "uma conta")
- ❌ Pular pra plano antes de fechar branches críticos
- ❌ Listar opções sem recomendar (você é o engenheiro)
- ❌ Escrever código de exemplo (isso é `/dev-coding`)
- ❌ Discutir libs específicas em detalhe (deixa pra `/dev-plan` via discovery)
- ❌ Documentar implementação no BRIEF (BRIEF é problema + escopo + decisões, NÃO implementação)
- ❌ BRIEF completo para tarefa S (cerimônia é imposto — triagem existe pra isso)

## Próximo passo

Quando o BRIEF estiver fechado, sugerir explicitamente:

> *"BRIEF fechado em `.plans/<feature>/BRIEF.md`. Pronto pra `/dev-plan` transformar em PLAN.md atômico?"*

Para tarefa **S** triada sem BRIEF: ofereça executar direto com checklist inline de 2-4 itens verificáveis.

