Projeto Capstone: Desenvolvendo uma Aplicação do Zero

📚 Navegação da Série: O capítulo anterior 47 Modo de Voz ensinou a usar o ditado de voz para inserir prompts no terminal. Este capítulo atua como a consolidação prática da série — não apresentaremos novas ferramentas, mas desenvolveremos um projeto real de escopo intermediário ligando regras do CLAUDE.md, permissões, servidores MCP, subagentes, checkpoints e Git do início à entrega final.

Ao analisar o histórico de projetos desenvolvidos com o Claude Code, percebe-se um padrão comum: os cenários em que a ferramenta agrega mais valor não se limitam a edições simples de uma linha, mas englobam projetos de escopo médio que duram múltiplas sessões de chat e interagem com diferentes recursos da CLI.

Criar uma aplicação do zero — lidando com MCP para ler documentações externas, subagentes para revisar códigos, checkpoints para reverter edições e estruturando commits claros no Git — exige alinhar os diferentes recursos estudados ao longo dos capítulos. O projeto passa de uma lista de comandos isolados para um fluxo contínuo de engenharia de software.

Este capítulo preenche a lacuna entre "conhecer as ferramentas" e "aplicá-las de forma conjunta em um projeto de desenvolvimento real". No Capítulo 39, cobrimos uma prática rápida de script local. Neste capítulo, aumentaremos a complexidade: o projeto abrangerá múltiplos arquivos, persistência de dados, testes automatizados e gestão de sessões de chat com retrocessos seguros.

Analogia: Regência de uma orquestra. Você já aprendeu a manusear o violino, os instrumentos de sopro e a percussão — dominando as particularidades de cada ferramenta. No entanto, reger uma orquestra para executar uma sinfonia completa exige coordenar quando cada instrumento entra, qual deles lidera a melodia e como manter o ritmo síncrono. Neste capítulo, você atuará como o regente, alinhando CLAUDE.md, permissões, MCP, subagentes, checkpoints e Git no tempo de execução correto.

Ao ler este capítulo, você obterá:

• O fluxo de trabalho de desenvolvimento de um projeto de escopo médio (do início ao deploy), identificando em qual etapa cada recurso é acionado.
• A técnica de gestão de contexto entre sessões: como usar --resume, arquivos de especificação (SPEC) e checkpoints para dividir o projeto em etapas seguras de dias de trabalho.
• O roteiro passo a passo com comandos do console, diagnósticos e saídas esperadas.
• Um repositório funcional construído do zero (utilitário de linha de comando todo-cli com persistência em JSON, testes unitários e documentação), integrando CLAUDE.md, permissões, MCP, subagentes, checkpoints e Git.
• Uma tabela comparativa contrapondo a execução de scripts simples locais e o desenvolvimento de projetos reais complexos de larga escala.

---

01 Visão Geral: O Fluxo de Desenvolvimento de um Projeto Médio

Antes de iniciar a escrita de código, observe a estrutura de execução do projeto. O fluxo de desenvolvimento de uma aplicação de médio porte repete as etapas básicas de scripts pequenos, mas introduz subagentes e MCPs de forma estruturada:

A representação gráfica detalha a esteira de desenvolvimento como um ciclo interativo: as seis fases se conectam sequencialmente e a linha de retorno indica que, ao estourar o limite de contexto de uma sessão, você deve documentar a etapa atual e abrir um novo chat limpo retomando a partir da fase de Planejamento. Isso evita que o agente perca agilidade analítica.

Duas diferenças centrais diferenciam este fluxo das práticas de scripts isolados:

1. Gestão de Sessões Sequenciais: O histórico da conversa não deve ser estendido indefinidamente. Sessões longas acumulam tokens desnecessários na memória de contexto da CLI, tornando a IA imprecisa (Capítulo 19). Deve-se organizar marcos de entregas locais, limpar a sessão e retomar o trabalho com o contexto limpo.
2. Uso de Recursos Especializados: Projetos de médio porte exigem o consumo de documentação via MCP para evitar dados desatualizados e a delegação de tarefas de revisão para subagentes independentes.

A documentação oficial resume o princípio de escala de tarefas:

Uma vez validada a dinâmica de trabalho com o Claude, escale sua produtividade utilizando sessões concorrentes, automações em lote e ramificações de subagentes.

Nosso objetivo é coordenar essas ferramentas em cada etapa do projeto.

💡 Resumo em uma frase: O desenvolvimento de projetos médios segue o fluxo "Setup → Planejamento (SPEC) → MCP → Subagentes → Checkpoints → Entrega", exigindo a divisão do trabalho em sessões limpas de chat conectadas por especificações.

---

02 Setup do Projeto: Estrutura do CLAUDE.md e Diretrizes de Permissão

A primeira etapa consiste na preparação do repositório local, definindo as regras de comportamento do agente no CLAUDE.md e estabelecendo a base de permissões no arquivo settings.

Construiremos um utilitário de lista de tarefas via linha de comando em Python chamado todo-cli. Ele permitirá cadastrar tarefas, listar itens ativos, marcar conclusões de pendências, persistir os dados em um arquivo JSON local, incluir testes unitários estruturados e uma documentação README básica. O projeto utiliza apenas bibliotecas nativas do Python, facilitando a execução em qualquer sistema operacional.

Passo 1: Criar a pasta do projeto e inicializar o repositório Git

Execute no seu terminal local:

mkdir todo-cli && cd todo-cli && git init

A inicialização do repositório Git no início do projeto garante um ponto de restauração limpo caso você precise descartar as alterações de uma sessão inteira.

Passo 2: Iniciar a sessão e definir as diretrizes do CLAUDE.md

Inicie a CLI:

claude

Na janela de chat, solicite a criação do arquivo de orientação CLAUDE.md (em vez do comando /init, instruiremos as diretrizes de forma direta para focar na especificação do Python):

Crie o arquivo CLAUDE.md na raiz do projeto com as seguintes regras de desenvolvimento:
1. Este utilitario utiliza exclusivamente a biblioteca padrao do Python, sem dependencias externas de terceiros.
2. Os dados de tarefas devem ser persistidos no arquivo local todos.json na raiz do projeto.
3. Todas as implementacoes devem vir acompanhadas de testes usando a biblioteca unittest, executados via comando "python3 -m unittest".
4. Mensagens de commits devem ser escritas em portugues, utilizando os prefixos convencionais feat:, fix: e docs:.

A IA apresenta as alterações e grava o arquivo de texto CLAUDE.md. Esse arquivo servirá como ponto de partida para guiar o comportamento do Claude em todas as próximas sessões abertas no diretório, evitando a necessidade de repetir as regras operacionais do projeto a cada novo chat.

Lembre-se de manter o CLAUDE.md objetivo, conforme a orientação oficial de documentação:

Mantenha o arquivo CLAUDE.md enxuto. Cada linha mantida no arquivo deve evitar erros recorrentes da IA; delete regras redundantes.

Passo 3: Configurar as permissões padrão no settings.json

Como editaremos múltiplos arquivos e executaremos a suite de testes frequentemente, configure regras de permissão no terminal para evitar interrupções de aprovação desnecessárias a cada execução de comando (Capítulo 20).

Opções de gestão de permissão para projetos médios:

Modo de Permissão	Mecanismo de Ação	Indicação Prática
Lista de Liberação (Allowlist)	Permite cadastrar comandos específicos na lista de liberação automática (como a suite de testes locais via /permissions).	Para comandos de rotina executados frequentemente pelo agente.
Modo Plan (Modo de Planejamento)	Ativado via atalho Shift+Tab ou parâmetro --permission-mode plan. A IA detalha a lógica em texto antes de aplicar mudanças.	Para refatorações extensas que exigem alinhamento prévio de arquitetura.
Modo Auto (Modo Automático)	Ativado via claude --permission-mode auto. A CLI aprova comandos de forma autônoma, exceto os contidos na lista deny.	Para acelerar desenvolvimentos locais em diretórios isolados e confiáveis.

Para o desenvolvimento do todo-cli, utilizaremos a Allowlist cadastrando o comando de testes unitários python3 -m unittest na lista de comandos auto-aprovados e ativaremos o Modo Plan sempre que iniciarmos a estruturação de novos comandos do utilitário, garantindo controle de arquitetura.

Delegar maior autonomia para a IA exige que você configure checkpoints do Git ou backups locais de forma sistemática para reverter edições incorretas.

💡 Resumo em uma frase: O setup inicial exige inicializar o Git, criar um CLAUDE.md com diretrizes básicas (sem dependências e com foco em testes unitários) e parametrizar permissões de comandos de testes na lista de liberação.

---

03 Planejamento: Elaboração da Especificação Técnica (SPEC.md)

Com o ambiente configurado, a próxima etapa é o planejamento da aplicação. Em projetos médios, crie um documento de especificação técnica chamado SPEC.md antes de iniciar a escrita de código.

Evite iniciar a codificação a partir de ideias vagas no chat. Isso pode resultar em mudanças frequentes de nomes de variáveis, caminhos de persistência inconsistentes e retrabalho durante a estruturação de arquivos adicionais.

Passo 1: Entrevistar a IA para modelar a especificação do projeto

Mude a CLI para o Modo Plan (Shift+Tab) e solicite que a IA ajude a estruturar as regras técnicas do software por meio de perguntas específicas:

Utilize a ferramenta AskUserQuestion para me entrevistar sobre as definicoes tecnicas do todo-cli:
- Estrutura de parametros aceitos no console (subcomandos).
- Modelagem do JSON de tarefas (campos, IDs, tipos).
- Comportamento de tratamento de arquivos (como tratar JSON corrompido ou ausente).
Consolide as respostas no arquivo SPEC.md na raiz do projeto.

A IA fará perguntas pontuais sobre a lógica da aplicação (por exemplo: "Tarefas duplicadas são permitidas?", "Como o utilitário deve se comportar se o arquivo JSON estiver corrompido?", "Quais os subcomandos exatos desejados?"). Após responder, as definições são salvas no arquivo SPEC.md.

A documentação detalha as boas práticas de redação de especificações:

Especificações de qualidade descrevem os arquivos afetados, as interfaces expostas, os limites técnicos fora de escopo e indicam o passo a passo de validação e testes para homologação.

Esse processo de perguntas e respostas ajuda a identificar lacunas de lógica (como validação de IDs de tarefas ou tratamento de caracteres especiais) antes de iniciar a escrita física do código.

Passo 2: Dividir as etapas de desenvolvimento em sessões limpas de chat

Com o documento SPEC.md pronto na raiz, divida o desenvolvimento em metas claras para cada sessão:

• Sessão 1: Inicialização do arquivo todo.py, funções de persistência do JSON, comando de adição (add) e testes unitários correspondentes.
• Sessão 2: Implementação do comando de exibição (list), conclusão de tarefas (done) e testes unitários associados.
• Sessão 3: Tratamento de exceções (leitura de arquivos corrompidos, listas vazias) e validação final da suite de testes.
• Sessão 4: Documentação técnica no README, linting e entrega final.

Passo 3: Retomando sessões com histórico limpo

Ao final de cada etapa, limpe o chat ativo para limpar a memória do terminal e inicie a próxima sessão indicando o ponto de partida a partir do arquivo de especificação física do disco:

# Comando para iniciar o novo chat importando o contexto anterior
Consulte o arquivo SPEC.md e os logs de commits do Git para identificar onde paramos. Descreva a proxima etapa de implementacao sem alterar nenhum arquivo ainda.

Utilizar o SPEC.md e o histórico do Git como pontos de referência de contexto é mais eficiente do que carregar todo o histórico de conversas passadas na memória do console, poupando espaço de tokens na janela de contexto (Capítulo 19).

💡 Resumo em uma frase: O planejamento exige estruturar um arquivo SPEC.md respondendo a perguntas da IA sobre a arquitetura e limites do utilitário, dividindo o desenvolvimento em etapas executadas em sessões de chat limpas.

---

04 Conexões de Rede: Consumindo Documentações via MCP

Durante a escrita do código, você pode precisar consultar a sintaxe exata de bibliotecas ou padrões da linguagem. O protocolo MCP (Model Context Protocol) permite que a IA conecte-se a serviços externos para consultar documentações atualizadas (Capítulo 22).

Identifique cenários comuns de cópia manual de dados:

Se você se deparar com a necessidade de copiar documentações de APIs do navegador e colá-las no chat do Claude, este é o indicador de que você deve configurar e conectar um servidor MCP correspondente.

Construir a ponte MCP economiza tempo de desenvolvimento. Conectaremos o servidor MCP de documentação técnica oficial da Anthropic para servir de repositório de consultas.

Passo 1: Registrar o servidor de consultas na CLI (no terminal do sistema)

claude mcp add --transport http claude-code-docs https://code.claude.com/docs/mcp

Nota: O servidor é hospedado de forma remota, necessitando de conexão ativa de internet e proxies configurados se estiver sob infraestrutura corporativa restrita (Capítulo 46).

Passo 2: Confirmar o registro do servidor no ecossistema

claude mcp list

A listagem deve conter o item claude-code-docs marcado com o status de conectado (✓ Connected).

Passo 3: Direcionar consultas técnicas pelo servidor MCP no chat

Consulte o servidor claude-code-docs para identificar a sintaxe correta e exemplos de uso do metodo assertRaises no modulo unittest do Python.

O Claude Code aciona o servidor de documentação correspondente, coleta os dados técnicos e apresenta a sintaxe de teste unitário correta no chat. O console exibirá a tag do servidor claude-code-docs ao lado da resposta para confirmar que a informação foi coletada do banco de dados oficial de consulta.

Para projetos empresariais, as conexões MCP estendem-se a outras bases de dados:

• Integração com GitHub: Servidores MCP para abrir tarefas, gerenciar revisões e automatizar PRs de forma ágil.
• Leitura de Bancos de Dados: Conectores MCP (como PostgreSQL) para analisar estruturas de tabelas (priorize contas de leitura para segurança de dados).
• Consumo de Telas: Integração com Figma para inspecionar componentes de layout de interfaces.

Lembre-se de remover os servidores MCP inativos da sua lista ao encerrar o desenvolvimento (claude mcp remove <nome>) para liberar recursos de memória nas próximas conversas da CLI.

💡 Resumo em uma frase: A integração MCP conecta a IA a fontes de dados externas (como o servidor oficial de documentação); consulte dados técnicos de forma nativa e remova os conectores inativos para preservar o espaço de contexto.

---

05 Delegação de Trabalho: Analisando Código via Subagentes

À medida que novos arquivos de lógica e suites de testes são adicionados, o contexto do repositório aumenta. Para evitar estourar o limite de tokens da sessão principal, delegue tarefas secundárias (como inspeção de arquivos ou análises de segurança) para subagentes independentes (Capítulo 23).

A documentação oficial destaca as vantagens técnicas de estruturar ramificações de processos:

Por conta dos limites de janela de contexto do chat principal, instanciar subagentes é uma das estratégias de engenharia mais eficientes do Claude Code. Eles operam em buffers de memória independentes e retornam apenas resumos das análises executadas.

O chat principal atua como regente, mantendo foco na tarefa ativa do programador.

Passo 1: Instanciar subagente para mapear o uso do repositório

Solicite no chat que um subagente localize onde ocorrem as operações físicas de leitura de dados no disco:

Instancie um subagente para ler o projeto e mapear onde estao estruturadas as funcoes de leitura e gravacao do arquivo todos.json. Retorne apenas uma lista indicando arquivos e linhas, sem exibir o codigo-fonte completo.

O subagente é inicializado em uma sessão de buffer secundária, realiza a busca física no disco, localiza as declarações nos arquivos e retorna um resumo conciso. O histórico completo de linhas lidas pelo subagente permanece em sua sessão temporária, deixando o chat principal livre de consumo de tokens desnecessários.

Passo 2: Revisar o código com o validador de subagente

Após a IA concluir as implementações, verifique a qualidade lógica e procure por falhas lógicas abrindo uma sessão de code-review independente:

/code-review

O validador padrão analisa as modificações em um subagente isolado e indica se existem problemas estruturais ou testes pendentes no código proposto.

Utilize o validador de forma focada para manter o desempenho do processo:

Oriente o agente de revisão a apontar problemas de corretude lógica ou requisitos ausentes do documento SPEC, tratando divergências estéticas de estilo como observações opcionais.

Isso evita logs extensos contendo apenas formatações estéticas de sintaxes.

💡 Resumo em uma frase: O uso de subagentes permite isolar tarefas de análise e revisão de código (como o comando /code-review) em contextos de memórias limpos, preservando o desempenho da sessão principal de chat.

---

06 Reversão de Erros: Controle de Checkpoints e Rollbacks do Git

Durante o desenvolvimento de funcionalidades complexas, edições incorretas ou caminhos de refatoração equivocados podem quebrar a aplicação. Esta seção descreve como reverter alterações usando checkpoints internos e comandos do Git.

Evite tentar corrigir um arquivo que foi desconfigurado pela IA adicionando novas instruções de correção sobre o código quebrado no mesmo chat. Isso estende o histórico de contexto com lógica incorreta, reduzindo a precisão das próximas respostas do agente.

A abordagem recomendada é descartar as alterações incorretas por completo, retornar o repositório ao último estado funcional conhecido e reiniciar a tarefa com prompts mais detalhados.

Opções de reversão de código:

Nível de Descarte	Ferramenta Utilizada	Ponto de Restauração	Cenário de Uso
Descarte Leve (Local)	Comando /rewind ou tecla Esc consecutiva.	Remove as edições feitas na sessão de chat ativa.	Para descartar edições parciais em um arquivo de forma ágil.
Descarte Pesado (Repositório)	Comandos do Git (git restore . ou git reset --hard <hash>).	Retorna a pasta do projeto para o estado do último commit salvo.	Para descartar alterações que afetaram múltiplos arquivos de forma desordenada.

O comando /rewind exibe a lista de edições locais da sessão para você escolher o ponto de reversão. Lembre-se do limite técnico da ferramenta:

O sistema de checkpoints monitora exclusivamente alterações de arquivos de código editados pelo Claude na sessão ativa, não registrando alterações geradas por comandos externos de console Bash ou servindo como substituto para o versionamento do Git.

Mantenha a rotina de realizar commits no Git a cada nova funcionalidade do SPEC.md que for validada na suite de testes unitários. Se a IA desconfigurar múltiplos arquivos em uma tarefa de refatoração complexa, execute git reset --hard para restaurar o estado funcional anterior em poucos segundos.

Após realizar o rollback das alterações, revise a instrução enviada no prompt original e adicione restrições mais detalhadas para evitar que a IA repita a edição incorreta (por exemplo: "Edite apenas o corpo do método X, mantendo a assinatura e os parâmetros originais sem alterações").

💡 Resumo em uma frase: Em caso de falhas na edição do código, descarte as alterações usando o comando /rewind (descarte local) ou git reset --hard (descarte do repositório) e reescreva a instrução original com maior nível de detalhamento.

---

07 Exercício Prático: Desenvolvendo o todo-cli do Início ao Commit

Construiremos as duas primeiras etapas da nossa aplicação de tarefas, aplicando as diretrizes de fluxo de trabalho abordadas.

Requisitos: interpretador Python 3.x operacional no sistema operacional, Git configurado, Claude Code operacional.

Passo 1: Setup do repositório e regras (no terminal do sistema)

mkdir todo-cli && cd todo-cli && git init && claude

Na CLI do Claude, crie as regras básicas do CLAUDE.md:

Crie o arquivo CLAUDE.md na raiz indicando:
- Uso exclusivo da biblioteca padrao Python.
- Persistencia no arquivo todos.json na raiz do projeto.
- Suite de testes unittest executados via "python3 -m unittest".
- Commits em portugues usando prefixos feat:, fix:, docs:.

Cadastre a suite de testes locais na lista de liberação automática executando /permissions e adicionando o comando Bash(python3 -m unittest*) na lista de permitidos.

Passo 2: Criar o documento de especificações (SPEC.md)

Ative o Modo Plan (Shift+Tab) e solicite a criação do escopo:

Estruture a especificacao SPEC.md na raiz do projeto para o utilitario todo-cli. Ele deve conter:
- Arquivo de execucao todo.py.
- Subcomando "add" para registrar tarefas (salvando ID sequencial, texto da tarefa e status de conclusao no todos.json).
- Subcomando "list" para exibir as tarefas no console formatadas.
- Arquivo de testes test_todo.py validando a escrita do JSON e o parse de argumentos.

A IA apresenta as seções e salva o arquivo SPEC.md.

Passo 3: Implementar a base da aplicação e os testes unitários

Mude para o modo tradicional de interação (Shift+Tab) e solicite o desenvolvimento do código:

Desenvolva a estrutura inicial do todo.py e test_todo.py contendo a lógica e testes para as funções de add e list conforme a especificacao.

Resultado esperado: A CLI do Claude Code analisa as diretrizes e cria o código do utilitário todo.py (usando argparse para parsing e json para persistência) e o arquivo de validações test_todo.py. Aprove as alterações de diffs apresentadas no console.

Passo 4: Executar a suite de testes unitários

Solicite a execução dos testes no console da CLI:

Execute a suite de testes unitarios do projeto para validar o comportamento inicial.

Resultado esperado: O Claude roda o comando python3 -m unittest de forma automatizada (sem interrupções de confirmação, devido à regra definida na Allowlist) e retorna o status de sucesso:

...
----------------------------------------------------------------------
Ran 3 tests in 0.002s

OK

Passo 5: Validar a execução no console local

Solicite o teste interativo do utilitário no terminal para verificar a persistência dos dados:

Adicione duas tarefas de teste usando a CLI local e exiba a listagem no console para verificar a formatacao.

Resultado esperado: A IA executa comandos similares aos listados abaixo no terminal local:

python3 todo.py add "Estudar capitulo 48 do guia"
python3 todo.py add "Validar projeto capstone"
python3 todo.py list

O console exibe as tarefas registradas no formato de saída definido na especificação:

1. [ ] Estudar capitulo 48 do guia
2. [ ] Validar projeto capstone

Passo 6: Auditar alterações e realizar o commit

Solicite a auditoria dos arquivos modificados e a criação do commit local:

Verifique quais arquivos foram modificados nesta sessao e realize o commit local com uma mensagem estruturada seguindo o padrao do projeto.

Resultado esperado: O Claude executa o status de arquivos, sugere a mensagem de commit (como feat: adiciona funcoes iniciais de add e list no todo-cli) e solicita sua aprovação para rodar o commit do Git. Confirme a execução.

A publicação das alterações no repositório remoto via git push deve ser executada de forma manual por você no terminal externo do sistema, fora do controle da IA.

💡 Resumo em uma frase: O exercício guiará você na inicialização do repositório, gravação de regras de testes, geração da especificação SPEC, desenvolvimento do código e validação física das saídas no console antes de gerar o commit.

---

08 Comparativo: Projetos Simples vs. Desenvolvimento de Escala

Observe as diferenças de comportamento de desenvolvimento conforme o tamanho do projeto aumenta:

Área de Análise	Execuções Simples de Rotina (Scripting)	Desenvolvimento de Escala (Projetos Médios)
Documentação Local	CLAUDE.md enxuto com poucas diretrizes de sintaxe.	CLAUDE.md detalhado integrado a especificações em formato de arquivos (SPEC.md).
Planejamento	Lógica implícita no próprio corpo do prompt.	Entrevistas prévias para mapeamento de arquitetura salvando as definições em arquivo físico.
Escopo de Sessões	Uma única sessão de chat resolve toda a tarefa.	Segmentação em múltiplos chats limpos retomando o trabalho com o comando --resume.
Fontes de Consulta	Confiança no banco de dados interno de treinamento da IA.	Conexão com bases atualizadas via servidores de protocolo MCP.
Qualidade de Código	Revisão visual básica feita pelo próprio programador.	Auditorias lógicas dedicadas em contextos de memória isolados com subagentes (/code-review).
Reversibilidade	Descarte básico de linhas de código usando atalhos de console.	Rollback do repositório usando comandos de versionamento Git (git reset --hard).
Entrega	Cópia do script resultante para uso imediato.	Processo de commits estruturados locais antes da publicação manual no servidor remoto.

Não tente aplicar a agilidade de scripts rápidos de rotina em projetos de larga escala. Estruturar regras de documentação, planejar especificações, gerenciar sessões e realizar commits organizados garante a estabilidade de projetos complexos desenvolvidos com inteligência artificial.

💡 Resumo em uma frase: À medida que o tamanho do projeto aumenta, a importância de manter especificações documentadas, testar de forma sistemática e isolar as conversas com a IA torna-se essencial para evitar o acúmulo de contexto e falhas de lógica.

---

09 Resumo

O desenvolvimento de projetos de médio porte com o Claude Code exige alinhar os recursos de orientação, segurança e versionamento da CLI para manter o repositório organizado e funcional.

Pontos estruturais revisados neste capítulo:

Fase do Projeto	Abordagem Recomendada
Setup	Configure as diretrizes do CLAUDE.md e parametrize as permissões de comandos de testes na lista de liberação automática.
Planejamento	Crie um documento de especificações (SPEC.md) mapeando limites lógicos e comportamentos de arquivos antes da escrita de código.
Sessões	Limite o histórico de conversas dividindo o desenvolvimento em sessões de chat limpas conectadas pelas hashes do Git e arquivo SPEC.
Consultas	Utilize servidores MCP locais ou oficiais para buscar dados e sintaxes de forma dinâmica e atualizada no console.
Qualidade	Delegue revisões para subagentes em buffers de memória separados (/code-review), evitando estourar a janela de contexto.
Segurança	Utilize a reversão de arquivos via /rewind ou Git em caso de edições incorretas e gerencie commits parciais de forma sistemática.

Dominar a orquestração dessas etapas capacita você a liderar o desenvolvimento de aplicações robustas e estruturadas usando o Claude Code como assistente de desenvolvimento.

---

O próximo capítulo, 49 "Diretrizes de Boas Práticas", consolidará as principais recomendações e orientações de uso prático coletadas com desenvolvedores experientes. Veremos como otimizar o consumo de tokens e a precisão do agente no dia a dia. Nos vemos no próximo capítulo!

---

Leituras Recomendadas

• Padrões de Execução e Correção de Bugs
• Guia Completo de Comandos da CLI
• Desenvolvimento e Empacotamento de Plugins

---