O fluxo de dev com IA Brainstorm → Plan → Cook → Ship (com AgentKit)

por Jasmine, uma desenvolvedora que roda exatamente este loop brainstorm-plan-cook-ship com o Claude Code e o AgentKit em trabalho real de produção.

A maioria dos artigos de "dicas de código com IA" te entrega uma pilha de prompts e deseja boa sorte. Isso não é um fluxo de trabalho — é um saco de truques. O que de fato move o ponteiro é um pipeline repetível: as mesmas fases, na mesma ordem, com um portão de verificação em cada parada. Este é esse pipeline, rodado de ponta a ponta em uma feature real, com os comandos exatos de cada fase.

Qual AgentKit? (não o OpenAI AgentKit)

Uma desambiguação rápida, porque o nome se choca. O AgentKit deste artigo é o kit para o Claude Code em agentkit.best (20% de desconto pelo link) — um pacote de skills, agents e slash commands que você controla pela CLI ak. Antes se chamava "Claude Kit" (a CLI ck foi renomeada para ak).

Ele não é o OpenAI AgentKit (Agent Builder, ChatKit e o Connector Registry), lançado em 6 de outubro de 2025. Mesma palavra, produto completamente diferente. Se você caiu aqui procurando a ferramenta da OpenAI para construir agents de chat, não é esta — aqui a conversa é sobre um fluxo de codificação disciplinado por cima do Claude Code. Totalmente nova no Claude Code? Comece por aqui primeiro.

Por que um fluxo com nome vence o prompt improvisado

Quando você só vai batendo papo por uma feature, três modos de falha aparecem sem parar. Primeiro, o contexto enche — quando o Claude está fundo na implementação, ele já esqueceu metade do que vocês combinaram no começo. Segundo, o Claude "parece pronto" sem verificar: ele reporta sucesso, você roda o código e não funciona. Terceiro, o escopo desvia — você pediu um rate limiter e recebeu um rate limiter mais uma refatoração de três arquivos que não tinham nada a ver.

A solução é um pipeline que separa pensar de fazer e coloca um portão de checagem em cada parada. A própria orientação da Anthropic aponta na mesma direção: a documentação de boas práticas do Claude Code (acessada em 2026-08-09) recomenda um loop explore → plan → code → commit e, o mais importante, manda você "dar ao Claude uma forma de verificar" a saída. O brainstorm-plan-cook-ship é a atualização operacional desse conselho: em vez de lembrar de promptar cada fase na mão, você transforma cada fase em um comando com um artefato definido e um portão definido. Mesmos princípios, menos disciplina exigida de você, mais consistência no que sai. É isso que faz dele um fluxo de código com IA repetível, e não uma sessão de sorte.

Há um segundo ganho, mais sutil: cada fase nomeada é uma fronteira de contexto natural. O Brainstorm produz um resultado curto, não uma transcrição; o Plan produz um arquivo que você entrega a uma sessão nova; o Cook trabalha a partir desse arquivo; o Ship revisa num contexto limpo. Como cada fase passa adiante um artefato pequeno e durável em vez de uma conversa inchada, você escapa por completo da falha do "contexto enche" — o modelo que faz o Cook nunca precisa lembrar do brainstorm inteiro, só do plano que recebeu. O prompt improvisado não consegue isso, porque tudo vive numa única thread que só cresce.

As 4 fases num relance

Aqui está o loop inteiro em uma tabela — o que cada fase produz, o comando e o portão que tem de passar antes de você seguir. Tudo abaixo é só esta tabela expandida com execuções reais.

Fase 1 - Brainstorm: trave o resultado antes de tocar no código

O objetivo do brainstorm é chato de propósito: transformar uma intenção vaga ("adicionar login") em um resultado aceito com critérios de aceitação, e comparar algumas abordagens antes que alguém escreva uma linha. Pular isso é o motivo de tantas sessões de IA produzirem código confiante e errado — o modelo otimizou para um alvo que você nunca chegou a acordar.

Com o AgentKit, rode:

/ak:brainstorm add a Google OAuth callback route to the API

Ele te entrevista: o que "pronto" significa, restrições, não-objetivos e os critérios de aceitação. Você termina com um resultado curto e escrito que você de fato aprovou — não uma parede de código.

O equivalente no Claude Code puro é o plan mode. Comece a sessão em modo somente leitura para que ele não possa editar nada enquanto você pensa:

claude --permission-mode plan
# or toggle plan mode mid-session with Shift+Tab

Depois peça que ele te entreviste antes de propor qualquer coisa: "Me faça perguntas de esclarecimento até conseguir enunciar o resultado e os critérios de aceitação, e então pare." A diferença é que o AgentKit entrega isso como um comando repetível com um formato de saída consistente; o Claude Code puro te obriga a conduzir a entrevista sozinha toda vez.

Regra de decisão para esta fase: se você não consegue dizer em uma frase como é o "pronto", você não está pronta para planejar, muito menos para cozinhar.

Fase 2 - Plan: transforme o resultado numa especificação

O plan converte o resultado aceito em uma especificação escrita e autocontida: os arquivos que você vai mexer, as interfaces, o que está explicitamente fora de escopo e — a parte que todo mundo pula — como a mudança será verificada de ponta a ponta. Um plano preciso compensa muito mais do que ficar assistindo a implementação rolar na tela, porque um bom plano é o que você de fato revisa; o código só o segue.

/ak:plan implement the OAuth callback per the brainstorm outcome

O AgentKit produz um arquivo de plano em fases que você pode ler, editar e guardar. Quando o plano precisa primeiro entender um código desconhecido, ele delega a pesquisa a um subagent scout para o seu contexto principal ficar limpo:

/ak:scout # investigates the codebase, reports back without editing

Se está confusa sobre por que um subagent cuida da varredura em vez do agente principal — ou como skills, hooks e MCP se encaixam ao redor — eu destrinchei as peças em skills vs subagents vs hooks vs MCP. No Claude Code puro, você obtém o mesmo efeito com o plan mode mais a edição do plano proposto ali mesmo (use Ctrl+G para abri-lo no seu editor) antes de deixá-lo prosseguir.

Isto é desenvolvimento guiado por especificação em miniatura: escreva a spec, concordem com ela, e a implementação vira uma checklist em vez de um jogo de adivinhação. O sinal de que seu plano está bom o bastante para cozinhar é simples — uma outra pessoa de engenharia (ou uma sessão nova do Claude Code) conseguiria executá-lo sem te fazer uma única pergunta. Se ainda precisa dos seus comentários ao vivo para fazer sentido, não é um plano ainda; é uma ideia bruta, e cozinhar a partir de uma ideia bruta é como o escopo desvia.

Fase 3 - Cook: implemente com portões de verificação

O cook é onde o código é escrito — mas o ponto todo é que o loop fecha em uma checagem que passa, não no Claude dizer "pronto". Você executa o plano e o combina com testes para que cada parada tenha um portão.

/ak:cook # implements the approved plan, phase by phase
/ak:test # runs the test suite; failures feed back into the loop

O padrão que importa: dê ao modelo uma forma de provar que a mudança funciona antes de cantar vitória. Isso quer dizer rodar os testes, rodar o build ou dar diff em um screenshot — com a saída à vista. Se você usa o Claude Code puro, monte o mesmo portão com um Stop hook ou o comando /goal para que a sessão não possa se declarar pronta enquanto uma condição concreta não passar. Com esse portão no lugar, você pode até usar o /goal para rodar o loop cook-review-ship a noite toda.

Dois hábitos evitam que o cook saia dos trilhos. Corrija o rumo cedo — aperte Esc para interromper uma guinada errada, ou /rewind para voltar — em vez de deixá-lo cavar um buraco mais fundo. E rode /clear entre tarefas sem relação, para que contexto velho não vaze para a próxima mudança. Para qualquer coisa cabeluda (um teste instável, um bug desconhecido), destaque um subagent para investigar, para que a thread principal fique focada em entregar a feature.

Fase 4 - Ship: revise, então o PR

Aqui está a regra que promove o ship de "commita e reza" para algo em que você confiaria num time: o revisor que avalia o trabalho não é o que o escreveu. Um modelo que acabou de passar uma hora se convencendo de que o código está correto é o pior juiz possível desse código. Então você revisa num contexto novo primeiro.

/ak:code-review # a fresh reviewer grades the diff against the plan

Isso levanta uma passada adversarial — um subagent revisor (ou uma sessão limpa) que lê o diff contra o plano original e procura regressões, critérios de aceitação esquecidos e arestas mal-acabadas. Só depois que ele dá o aval é que você abre o PR:

/ak:ship # conventional commit + PR via gh

O AgentKit escreve um conventional commit e abre o pull request pela CLI gh. O equivalente cru é rodar /code-review numa sessão nova e depois gh pr create você mesma. Opcionalmente feche o loop com /ak:journal para capturar as decisões que você tomou — a sua eu do futuro vai agradecer à sua eu do presente quando revisitar por que o callback foi feito assim.

O loop completo em uma feature real (de ponta a ponta)

Vamos juntar tudo em uma feature pequena e real: adicionar uma rota de callback do Google OAuth a uma API existente. Aqui estão os quatro artefatos, lado a lado, do jeito que eles de fato se empilham numa execução.

1. Brainstorm → um resultado de duas linhas: "Adicionar GET /auth/google/callback que troca o code por tokens, cria/vincula o usuário e define um cookie de sessão. Não-objetivos: sem rotação de refresh token, sem nova UI." Aceitação: um novo teste de integração passa e um login manual faz o ciclo completo.
2. Plan → um arquivo de plano em fases: qual arquivo de rota, o helper de troca de token, o módulo de sessão que ele reutiliza, o tratamento de erro para um consentimento negado, a lista do que está fora de escopo e o teste exato a escrever.
3. Cook → o diff: a nova rota, o helper, um novo teste de integração, ligado ao código de sessão existente — com a execução do teste passando antes de parar.
4. Ship → uma revisão nova pega uma coisa (o caminho de consentimento negado retornava um 500 em vez de redirecionar), isso é corrigido, e então um conventional commit e o PR abrem.

Sobre tempo: a economia visível não vem de o modelo digitar mais rápido — vem de não refazer trabalho. Como o resultado foi travado na fase 1 e o plano foi revisado na fase 2, o cook da fase 3 raramente perambula, e a revisão da fase 4 pega o único defeito real antes que ele chegue a um revisor humano ou à CI. O loop caro da codificação improvisada — construir a coisa errada, descobrir tarde, desfazer — é exatamente o que os portões evitam. Uma feature desse tamanho poderia ter levado umas sessões espalhadas de prompt-and-pray; passada pelo pipeline, é uma passada única e focada com um PR limpo no fim.

Nota honesta sobre onde a pessoa ainda importa: o modelo nunca decide o resultado — eu decido, na fase 1 — e o achado da revisão na fase 4 é exatamente o tipo de julgamento que você não quer automatizar por completo. O fluxo tira o trabalho braçal e as armadilhas do "parece pronto"; ele não tira você.

Quando pular fases (não superprocesse um typo)

Este framework se paga em trabalho multiarquivo, desconhecido ou de abordagem incerta. É exagero para um conserto de uma linha. A regra de decisão que eu uso:

Se você consegue descrever o diff inteiro em uma frase, pule o brainstorm e o plan — vá direto para o cook. Corrigir um typo, subir uma versão, renomear uma variável: só faça (e ainda deixe um teste confirmar que nada quebrou).

Recorra ao pipeline completo quando qualquer uma destas for verdadeira: a mudança abrange vários arquivos, você não conhece bem aquela área do código, há mais de uma abordagem razoável, ou um erro é caro de desfazer. A arte toda é casar o peso do processo com o risco — um processo pesado numa mudança trivial é o seu próprio tipo de desperdício.

AgentKit vs fazer isso com o Claude Code puro

Deixa eu ser clara, porque é aqui que a honestidade importa: você não precisa do AgentKit para rodar este fluxo. O brainstorm-plan-cook-ship funciona com o Claude Code puro. Você pode construir seus próprios slash commands, escrever suas próprias skills e montar seus próprios Stop hooks para reproduzir cada portão descrito acima. Muita gente boa de dev faz exatamente isso.

O que o AgentKit te dá é a versão pré-montada e opinativa: os comandos /ak:*, 108+ skills e 45 agents (17 de engenharia + 28 de marketing) já montados e testados, para você pular as semanas de construir e manter o seu próprio kit. Ele também funciona com o GitHub Copilot, não só com o Claude Code. Quem precisa: gente que quer o fluxo agora e prefere não virar autora de ferramentas em meio período. Quem não precisa: gente que curte construir a própria biblioteca de comandos, ou cujas necessidades são estreitas o bastante para dois comandos custom darem conta. Se você está pesando opções, comparei-o com o resto do mercado em como o AgentKit se compara às alternativas.

Limitações & opinião honesta

Nenhuma ferramenta é livre de trade-offs, e fingir o contrário anularia o propósito deste artigo.

• Curva de aprendizado. Você ainda precisa saber Claude Code primeiro. O AgentKit acelera um fluxo; ele não te ensina os fundamentos. Se o Claude Code em si é novo para você, aprenda isso antes de empilhar um kit por cima.
• O preço é em USD e é um custo real: o Engineer Kit e o Marketing Kit são $99 cada, o bundle é $149 (o site não lista taxa recorrente para os kits), e há garantia de reembolso — embora o site não indique uma duração específica, então não presuma nenhuma.
• Confusão entre assinatura e pagamento único. Os kits são pagamento único; o Desktop App separado é uma assinatura anual ($19/ano). Fácil de confundir — leia o checkout com atenção.
• Alguma sobreposição. Algumas skills duplicam coisas que você talvez já roteie sozinha. O valor está na curadoria e na cola do fluxo, não em cada skill ser inédita.

FAQ

O que é o fluxo brainstorm-plan-cook-ship?

É um fluxo de dev com IA repetível de quatro fases: brainstorm (travar o resultado e os critérios de aceitação), plan (escrever uma especificação autocontida), cook (implementar mais testes até passarem) e ship (uma revisão adversarial num contexto novo, então abrir um PR). Ele operacionaliza o conselho explore-plan-code-commit da Anthropic em comandos nomeados com um portão de verificação em cada fase.

Preciso do AgentKit para usar este fluxo?

Não. O fluxo roda no Claude Code puro — você construiria seus próprios slash commands, skills e Stop hooks para ter os mesmos portões. O AgentKit é a versão pré-montada que já traz esses comandos (/ak:brainstorm, /ak:plan, /ak:cook, /ak:ship) para você não precisar montá-los sozinha.

O AgentKit é o mesmo que o OpenAI AgentKit?

Não. Este AgentKit é o kit para o Claude Code em agentkit.best, controlado pela CLI ak (antes Claude Kit / ck). O OpenAI AgentKit é um produto diferente (Agent Builder, ChatKit, Connector Registry) lançado em 6 de outubro de 2025. Mesmo nome, ferramentas sem relação.

Quais são os comandos exatos de cada fase?

Brainstorm: /ak:brainstorm. Plan: /ak:plan (com /ak:scout para pesquisa no código). Cook: /ak:cook mais /ak:test. Ship: /ak:code-review e então /ak:ship, com um /ak:journal opcional para capturar decisões.

Funciona com o GitHub Copilot também?

Sim. O AgentKit dá suporte tanto ao Claude Code quanto ao GitHub Copilot, então a mesma estrutura de fluxo fica disponível se o seu time está no Copilot em vez do Claude Code.

O AgentKit é pagamento único ou assinatura?

Os kits (Engineer $99, Marketing $99, bundle $149) são pagamento único — o site não lista taxa recorrente para eles e inclui atualizações vitalícias dos kits. O Desktop App separado é uma assinatura anual ($19/ano). São cobrados de formas diferentes, então confira o que você está de fato comprando.

Conclusão + pegue o kit

Esse é o loop inteiro: brainstorm para travar o resultado, plan para escrever a spec, cook para implementar atrás de um teste que passa, e ship depois que um revisor novo dá o aval. Fases nomeadas, um comando cada, um portão em cada parada — é isso que transforma sessões de sorte num fluxo de dev com IA repetível. Rode com o Claude Code puro, ou pule a montagem e use os comandos pré-prontos.

Quer o panorama completo antes de comprar? Leia primeiro o que o AgentKit inclui.