Prática de Introdução: Do Início à Entrega de uma Demanda Real

📚 Navegação da Série: O capítulo anterior 38 Manual de Referência de Plugins ensinou você a empacotar suas configurações locais para distribuição. Este capítulo muda completamente de ritmo — enquanto os trinta e oito capítulos anteriores focaram em "desmontar recursos um a um", este capítulo une esses recursos em uma rota de prática de desenvolvimento de ponta a ponta pela primeira vez: desde abrir o repositório, escrever o CLAUDE.md, enviar comandos, revisar alterações e validar a entrega, tudo em um fluxo contínuo. É a hora de unir as técnicas aprendidas em uma única tarefa.

A verdade é que a maioria das pessoas acredita que programar com IA é apenas "enviar uma frase e esperar o resultado" — explicar a demanda, deixar o Claude rodar e pegar o resultado para usar. Esse caminho parece simples, mas ao primeiro erro você descobre onde o fluxo quebra:

A IA desvia da rota proposta, altera três arquivos desnecessários sem aviso, ou o bug corrigido continua falhando na execução... e o tempo gasto para corrigir a bagunça acaba sendo maior do que se você fizesse tudo manualmente.

O problema não é a inteligência da ferramenta, mas sim a falta de pontos de validação ao longo do fluxo de trabalho.

Em resumo, existe uma barreira entre "conhecer comandos individuais" e "conectar comandos em um fluxo estruturado". Você praticou manobras, usou retrovisores e aprendeu a frear, mas para dirigir sozinho no trânsito real, precisa conectar essas ações na ordem correta. Este capítulo não trará recursos novos, focando em apenas um objetivo — guiar você na consolidação das peças aprendidas em um fluxo de desenvolvimento funcional de ponta a ponta.

Escolhemos uma tarefa intencionalmente pequena, mas que cobre todos os elementos do fluxo: adicionar uma nova funcionalidade a um script de contagem de palavras e corrigir um bug existente. A tarefa é simples, mas o caminho do início à entrega é completo e rigoroso.

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

• O fluxo padrão de desenvolvimento em seis etapas: "Abertura → Exploração → Planejamento → Execução → Validação → Entrega", especificando o que fazer e quais comandos rodar em cada momento.
• Um exercício prático guiado completo (adicionar parâmetro --top N e tratar crash por argumento vazio em um script Python), com os comandos e resultados esperados.
• Por que a diretriz "primeiro explorar, depois alterar" deve ser a sua principal memória muscular ao trabalhar com IA.
• Como utilizar o plan mode (Capítulo 20) para fazer com que a IA proponha a lógica antes de alterar arquivos, e como analisar as diferenças de diff geradas.
• Uma tabela comparativa de "Erros comuns de iniciantes vs. Boas práticas de profissionais" para identificar desvios de etapas.

---

01 Visão Geral: As Seis Etapas do Fluxo de Trabalho

Antes de iniciar os comandos, visualize o fluxo completo. Qualquer demanda real de desenvolvimento, seja ela grande ou pequena, segue estas seis etapas do início à entrega:

Analogia: Uma corrida de revezamento. Cada etapa funciona como um corredor que passa o bastão para o próximo: a Exploração entrega a compreensão do código para o Planejamento, o Planejamento entrega o escopo acordado para a Execução, e a Execução entrega as alterações físicas para a Validação. Se algum corredor deixar o bastão cair, o fluxo quebra e exige refazer o trabalho — o erro clássico de iniciantes é pular etapas, principalmente tentar "alterar o código sem explorar antes", iniciando a corrida sem receber o bastão.

Estas seis etapas consolidam as instruções de início rápido (quickstart) e fluxos comuns (common workflows) da documentação do Claude Code. A documentação oficial resume a importância do fluxo:

Permita que o Claude compreenda seu código antes de aplicar qualquer alteração.

O fluxo pode ser agilizado, mas nenhuma etapa deve ser pulada. Desenvolvedores experientes costumam combinar "Exploração + Planejamento" em um único prompt ou unir "Validação + Entrega" em um só comando, acelerando o ritmo — mas todas as etapas continuam presentes. O erro comum de iniciantes é reduzir o fluxo a apenas duas ações: "enviar demanda → aceitar resultado", ignorando as etapas intermediárias e tentando arremessar o bastão direto para a linha de chegada. Nas seções a seguir, faremos esse fluxo passo a passo em uma tarefa real, validando cada passagem de bastão. Em cada etapa, indicaremos o capítulo correspondente aos recursos aplicados para consolidar as ferramentas aprendidas.

💡 Resumo em uma frase: O fluxo de desenvolvimento baseia-se em seis etapas: Abertura → Exploração → Planejamento → Execução → Validação → Entrega, exigindo a passagem de bastão correta em cada transição; o erro mais comum é ignorar a exploração antes de iniciar edições.

---

02 Preparação: Criando o Repositório de Teste

Para que você possa seguir os passos de forma literal, criaremos um pequeno repositório de testes do zero. Ele consistirá em um script Python e um arquivo de texto, sem dependências externas, exigindo apenas ter o python3 instalado no sistema (nativo no Mac/Linux, ou via instalador no Windows).

Passo 1: Criar a pasta e os arquivos iniciais

No terminal do seu sistema, execute (esta etapa de preparação é manual, antes de iniciar o Claude Code):

mkdir wordcount-demo && cd wordcount-demo

Crie o arquivo wordcount.py com o seguinte código (este será o nosso código legado, contendo melhorias a serem feitas):

import sys
from collections import Counter

def count_words(path):
    with open(path) as f:
        text = f.read()
    words = text.lower().split()
    return Counter(words)

def main():
    path = sys.argv[1]
    counts = count_words(path)
    for word, n in counts.items():
        print(f"{word}: {n}")

if __name__ == "__main__":
    main()

Crie o arquivo sample.txt contendo o seguinte texto de teste:

the quick brown fox the lazy dog the fox

Passo 2: Executar o script localmente para validar

python3 wordcount.py sample.txt

Resultado esperado (a ordem das linhas pode variar, mas os valores de contagem devem ser idênticos):

the: 3
quick: 1
brown: 1
fox: 2
lazy: 1
dog: 1

Se o terminal exibir as contagens acima, o script está funcionando. Este código legado possui dois pontos a serem corrigidos:

• Falta de Funcionalidade: o script exibe todas as palavras encontradas, mas precisamos limitar a saída para mostrar apenas as "N palavras mais frequentes" via parâmetro.
• Bug Oculto: se você executar o script sem passar argumentos (python3 wordcount.py), ele falhará gerando um erro de índice IndexError no terminal, em vez de exibir um aviso amigável orientando a passar o arquivo.

Passo 3: Inicializar o repositório Git (essencial, não pule)

git init && git add . && git commit -m "init: script basico de contagem de palavras"

Resultado esperado: O Git confirma a criação del commit inicial contendo as alterações nos dois arquivos.

Por que comitar o código antes de começar? Porque commits são a sua rede de segurança definitiva. O Capítulo 37 detalhou como os checkpoints revertem edições do Claude de forma automática, mas o Git atua em um nível de histórico permanente. Ter um commit limpo antes de iniciar garante que, independentemente do que o Claude faça, você sempre poderá retornar ao ponto de partida com segurança. Não ter um ponto de partida limpo antes de autorizar grandes alterações automatizadas é um erro clássico que dificulta reversões.

💡 Resumo em uma frase: A pasta de testes contém um script Python simples e um arquivo de texto, executados de forma nativa com python3; a tarefa consiste em adicionar um parâmetro de limite e tratar a falha de argumento vazio; crie um commit no Git antes de iniciar para garantir a segurança da base.

---

03 Abertura: Iniciando a Sessão e Configurando o CLAUDE.md

Com a pasta de testes criada, iniciamos a primeira etapa — Abertura. Ela aplica os conceitos de inicialização (Capítulo 2), primeiro fluxo (Capítulo 7) e diretrizes do CLAUDE.md (Capítulos 12 e 18).

Passo 1: Iniciar o Claude Code na pasta do projeto

Abra o terminal dentro do diretório wordcount-demo e execute o comando claude. Iniciar a ferramenta fora da pasta raiz fará com que o Claude Code indexe arquivos indesejados no contexto da sessão.

claude

Resultado esperado: O terminal exibe a tela de inicialização do Claude Code apontando a pasta atual como wordcount-demo.

Passo 2: Criar um arquivo CLAUDE.md mínimo

Conforme analisado no Capítulo 18: um arquivo CLAUDE.md extenso que tenta ditar centenas de regras acaba sendo ignorado pela IA. Para este projeto simples, especifique apenas as duas regras fundamentais: como executar e as restrições de dependências. Solicite à IA no prompt da sessão (ou crie o arquivo manualmente):

Crie um arquivo CLAUDE.md na raiz do projeto especificando duas regras:
1. Este projeto usa apenas a biblioteca padrao do Python, nao instale dependencias de terceiros.
2. Para testar alteracoes, execute o comando: python3 wordcount.py sample.txt

Resultado esperado: O Claude apresenta a proposta do arquivo e solicita aprovação para gravá-lo (seguindo as regras de permissões do Capítulo 20). Após aprovar, o arquivo CLAUDE.md é gravado na raiz com o seguinte conteúdo:

# wordcount-demo

Um utilitário simples de contagem de palavras via terminal.

## Diretrizes de Desenvolvimento
- Use apenas a biblioteca padrão do Python; **não adicione dependências externas**.

## Comandos Úteis
- Validar execução: `python3 wordcount.py sample.txt`

O arquivo define as diretrizes essenciais. Mantenha as regras curtas e diretas para garantir a leitura pela IA.

Isso se assemelha ao comando /init visto no Capítulo 12. A diferença é que o /init executa uma varredura automática no repositório para deduzir as regras do projeto (ideal para repositórios maiores), enquanto para um script simples de dois arquivos, escrever as diretrizes diretamente garante um arquivo mais enxuto e preciso. Escolha a abordagem conforme o tamanho do projeto.

Por que criar o CLAUDE.md logo na abertura? Porque ele serve de referência de contexto para todos os prompts seguintes. A IA lembrará automaticamente de "não instalar bibliotecas de terceiros" e de "executar a validação" a cada alteração, sem demandar que você repita essas orientações em cada comando enviado.

💡 Resumo em uma frase: A abertura consiste em iniciar a CLI na pasta correta e gravar um CLAUDE.md básico com as regras do projeto; escrever regras simples manualmente garante maior precisão para escopos pequenos.

---

04 Exploração: Analisando o Código Antes de Alterar

Esta é a etapa mais importante para consolidar como hábito e que evita erros de lógica. Ela aplica as diretrizes de fluxos de exploração detalhadas no Capítulo 16.

Regra geral: o primeiro prompt da demanda deve focar em "entender", não em "alterar".

Tentar enviar comandos como "adicione o parâmetro --top ao script" logo de cara faz com que o Claude tente adivinhar a estrutura do código sem contexto, aumentando o risco de edições incorretas. O fluxo correto orienta pedir uma análise da estrutura antes de aplicar alterações:

Nao faca alteracoes no codigo ainda. Analise o arquivo @wordcount.py e explique o fluxo de execucao,
a funcao principal e aponte possíveis problemas de execucao ou falhas que identificar no codigo atual.

Note as boas práticas aplicadas no prompt:

• A instrução "Nao faca alteracoes no codigo ainda" estabelece um limite claro para a ação, impedindo a escrita de arquivos na etapa de leitura (Capítulo 15).
• A referência @wordcount.py anexa o arquivo de forma direta ao prompt usando a ferramenta de contexto da CLI (Capítulos 16 e 17), agilizando a leitura da IA.

Resultado esperado: O Claude analisa o arquivo e descreve a lógica: o script realiza a leitura do caminho passado e conta os termos usando Counter. A IA também destaca o bug oculto: a leitura direta de sys.argv[1] quebrará a execução com IndexError se o usuário iniciar o script sem passar argumentos.

O Claude identificou a falha antes mesmo de solicitarmos a correção. Isso valida a utilidade de explorar o código previamente: a IA compreende a estrutura atual e aponta pontos de atenção que ajudam a direcionar o desenvolvimento.

Em projetos reais, a exploração deve seguir um fluxo progressivo ("do macro ao micro"), conforme as boas práticas do ecossistema:

Apresente a estrutura de pastas e a arquitetura geral do projeto (sem alterar arquivos).

Identifique as classes e arquivos que gerenciam a autenticacao de usuarios e como interagem.

O primeiro prompt contextualiza o mapa de arquivos, e o segundo direciona a análise para o escopo das alterações. Evite pular a contextualização geral. Sem compreender o repositório, a IA pode propor alterações que conflitam com outros módulos do sistema. Dedicar alguns instantes para a exploração economiza tempo de depuração e reversões futuras.

Se a exploração demandar a leitura de muitos arquivos, o que consome limites de tokens de contexto (Capítulo 19), você pode delegar a leitura a um subagente (Capítulo 23) de forma isolada, coletando apenas o relatório final de análise e mantendo o contexto da sessão principal limpo.

💡 Resumo em uma frase: Ao receber uma tarefa, o primeiro passo é pedir para a IA analisar a estrutura sem alterar arquivos; explorar previamente ajuda a contextualizar a IA e identificar falhas de lógica antes de iniciar a escrita de código.

---

05 Planejamento: Alinhando a Solução no Plan Mode

Com a estrutura compreendida, a etapa de Planejamento serve para definir a lógica que a IA usará antes que ela comece a alterar os arquivos. Ela aplica o recurso de plan mode analisado no Capítulo 20.

Pedir uma proposta de alteração antes da escrita garante que a IA siga a lógica desejada por você, evitando caminhos de desenvolvimento indesejados.

Opção 1: Solicitar Proposta de Plano por Texto

Use uma instrução direta no prompt:

Desejo adicionar o parametro opcional --top N ao script para limitar a contagem de termos frequentes.
Tambem quero tratar o crash de argumento vazio que voce identificou.
Apresente uma proposta descrevendo como voce planeja alterar o codigo e quais funcoes serao modificadas. Nao aplique as alteracoes ainda.

Resultado esperado: O Claude retorna a proposta de solução: utilizar o módulo argparse da biblioteca padrão em substituição ao sys.argv, adicionar o argumento --top do tipo inteiro e usar a função Counter.most_common() para realizar o filtro de limite, tratando a ausência de parâmetros de forma amigável via CLI. A IA aguarda aprovação no console.

Opção 2: Ativar o Plan Mode da CLI

Para demandas complexas, é recomendado utilizar o modo de planejamento da CLI — que restringe a alteração de arquivos de código, permitindo que a IA execute apenas leituras e testes para formular a proposta:

claude --permission-mode plan

Ou alterne para o modo usando o atalho Shift+Tab no console (Capítulo 20). A documentação define a segurança desse modo:

O Claude formula planos de ação e faz buscas, mas impede qualquer alteração direta no código-fonte até que você aprove o plano.

Diferença de abordagens:

Abordagem	Funcionamento	Segurança	Cenário de Uso
Instrução no Prompt	Depende de a IA seguir a instrução de "não alterar" no texto	Flexível, mas sem bloqueio técnico	Pequenas melhorias sob supervisão direta
Plan Mode (CLI)	O sistema bloqueia chamadas de ferramentas de escrita no código	Rígida, impede alterações físicas no disco	Alterações complexas ou de larga escala

Para pequenas implementações como o parâmetro --top, a instrução por prompt atende bem; para alterações em múltiplos arquivos ou refatorações complexas, use o plan mode via Shift+Tab para garantir que nenhuma alteração física seja feita sem sua validação direta do plano.

💡 Resumo em uma frase: Proponha a lógica e alinhe a solução antes de autorizar escritas; use instruções textuais para tarefas simples e ative o plan mode (Shift+Tab) para garantir bloqueios físicos em grandes alterações.

---

06 Execução e Revisão: Aplicando Alterações com Validação de Diffs

Com a proposta aprovada, avançamos para a etapa de Execução e Revisão. Ela aplica os conceitos de confirmação de permissões analisados no Capítulo 20.

Passo 1: Autorizar a escrita dos arquivos

Instrua a IA a seguir com as modificações:

O plano esta correto. Pode aplicar as alteracoes no codigo.

Resultado esperado: O Claude inicia a alteração do arquivo wordcount.py. O diff das alterações é exibido no console para aprovação antes de salvar em disco (seguindo as configurações padrão analisadas no Capítulo 20).

Passo 2: Inspecionar o Diff no Console

Evite aprovar alterações sem inspecionar as linhas modificadas. Revise o diff apresentado no console:

- import sys
+ import argparse

- def main():
-     path = sys.argv[1]
-     counts = count_words(path)
-     for word, n in counts.items():
+ def main():
+     parser = argparse.ArgumentParser(description="Contador de palavras frequentes")
+     parser.add_argument("path", help="Caminho do arquivo de texto")
+     parser.add_argument("--top", type=int, default=None, help="Limite de palavras mais frequentes")
+     args = parser.parse_args()
+     counts = count_words(args.path)
+     items = counts.most_common(args.top) if args.top else counts.most_common()
+     for word, n in items:

Valide três pontos fundamentais: ① As alterações seguem o plano aprovado (uso do argparse); ② A função de contagem principal count_words não foi alterada desnecessariamente; ③ Nenhuma biblioteca de terceiros foi adicionada (respeitando o CLAUDE.md). Se as alterações estiverem corretas, confirme a aprovação.

Não ative o modo de aprovação automática de edições (acceptEdits do Capítulo 20) em projetos novos. Mantenha a validação manual de diffs ativa. Ela serve como a principal barreira para evitar escritas indesejadas no disco. Monitorar o diff no terminal é mais rápido do que corrigir implementações incorretas ou realizar rollbacks no Git depois que o arquivo foi gravado.

💡 Resumo em uma frase: Na etapa de execução, valide cada bloco de diff apresentado no console para garantir que as alterações correspondam ao plano aprovado e não violem regras de desenvolvimento do CLAUDE.md, usando a aprovação como barreira de segurança.

---

07 Validação: Executando Testes Práticos no Console

Após a conclusão da escrita do arquivo, a IA informará que a implementação foi concluída. Não conclua a tarefa sem rodar validações práticas locais. Esta etapa aplica as boas práticas de testes analisadas no Capítulo 16 e as regras do CLAUDE.md.

Regra de validação: teste os cenários de sucesso, erro e regressão localmente para garantir a integridade do código.

Passo 1: Validar a nova funcionalidade (--top)

python3 wordcount.py sample.txt --top 3

Resultado esperado (saída ordenada por frequência limitando-se aos 3 primeiros registros):

the: 3
fox: 2
quick: 1

O filtro por limite e a ordenação estão corretos.

Passo 2: Validar regressão de comandos legados

A chamada padrão sem o argumento --top deve continuar exibindo todos os termos da contagem:

python3 wordcount.py sample.txt

Resultado esperado: O terminal exibe a listagem completa das seis palavras, correspondendo ao resultado visto na Seção 2.

Passo 3: Validar a correção do bug de crash

Inicie o script sem argumentos para testar o tratamento do erro:

python3 wordcount.py

Resultado esperado: O script exibe a mensagem de ajuda do parser, saindo com código de erro amigável em vez de quebrar com a traceback de IndexError:

usage: wordcount.py [-h] [--top TOP] path
wordcount.py: error: the following arguments are required: path

As validações confirmam que a implementação atende aos requisitos de sucesso, erro e retrocompatibilidade.

Para aumentar a confiabilidade, peça à IA para criar um teste unitário que valide esses cenários, consolidando o fluxo:

Crie um teste automatizado simples em Python para validar as regras do script (sucesso, limite top e erro de argumento vazio).

Resultado esperado: O Claude grava um script de teste e o executa localmente exibindo os resultados corretos. O teste unitário serve como validação de integridade para modificações futuras.

Evite aceitar a conclusão de tarefas baseando-se apenas na confirmação textual da IA. Apenas a validação de execução local garante o funcionamento real da entrega.

💡 Resumo em uma frase: A validação consiste em executar cenários de sucesso, erro e regressão localmente; a aprovação da entrega depende de testes práticos, não apenas da confirmação textual da IA.

---

08 Entrega: Criando Commit e Validando o Histórico

Com as validações aprovadas, passamos para a última etapa — Entrega. Ela consolida o código modificado no controle de versão (Git), aplicando as diretrizes do Capítulo 7.

Passo 1: Consultar o status das alterações

Solicite um relatório de arquivos modificados na sessão:

Quais arquivos foram modificados nesta tarefa?

Resultado esperado: O Claude executa chamadas Git e exibe que apenas os arquivos wordcount.py e CLAUDE.md foram alterados ou adicionados.

Passo 2: Solicitar a gravação do commit

Gere uma mensagem de commit curta e clara em português e faça o commit das alteracoes.

Resultado esperado: O Claude sugere uma mensagem de commit (como feat: adiciona parametro --top e trata erro de argumentos no wordcount) e solicita aprovação para executar o comando git commit. Aprove a execução.

Lembre-se da separação de escopos de segurança: o Claude Code pode gravar commits locais com sua aprovação, mas ações que envolvam pushes para repositórios remotos (git push) devem ser executadas manualmente por você para manter o controle das entregas do repositório (assunto detalhado no Capítulo 43).

Passo 3: Validar o histórico do Git

Exiba o log do ultimo commit.

Resultado esperado: A CLI exibe o log de commit atualizado, confirmando o encerramento do fluxo de trabalho.

O script foi alterado, testado e comitado com segurança, completando o ciclo de desenvolvimento de ponta a ponta.

💡 Resumo em uma frase: A entrega conclui a tarefa revisando os arquivos modificados, gerando a mensagem de commit e salvando localmente; mantenha a execução de comandos remotos (como git push) sob seu controle direto.

---

09 Lidando com Falhas: Como Reverter Alterações de Forma Segura

Se durante a etapa de validação o código apresentar falhas ou a implementação não seguir a lógica desejada, evite acumular correções em cima de um código quebrado.

Realizar alterações corretivas sobre um escopo de código bagunçado polui o contexto e confunde a IA. A boa prática indica retornar a um estado estável limpo antes de refazer a instrução.

Dependendo do andamento, use uma das abordagens de retorno:

Ferramenta de Retorno	Comando / Atalho	Ponto de Restauração	Cenário de Uso
Checkpoint Rollback	Atalho /rewind	Estado do código antes da execução do prompt	Para remover uma alteração localizada de escrita recente
Git Restore	git restore .	Último commit salvo no Git local	Para limpar alterações complexas que corromperam a lógica do repositório

Caso precise refazer o fluxo, analise por que a primeira tentativa falhou. Geralmente, o problema decorre de falta de clareza nas instruções de restrição ou exploração insuficiente. Ajuste as regras no prompt e reinicie a etapa de planejamento a partir de uma base limpa.

💡 Resumo em uma frase: Em caso de falhas na validação, reverta o código para um estado estável limpo usando /rewind ou Git antes de tentar nova implementação, evitando correções parciais sobre código bagunçado.

---

10 Comparativo: Fluxo Profissional vs. Erros de Iniciantes

Considere as diferenças de abordagem no fluxo de desenvolvimento:

Etapa	❌ Erro de Iniciante	\✅ Fluxo Profissional
Abertura	Inicia a sessão em pastas aleatórias sem regras de diretrizes.	Abre o console na pasta raiz e documenta restrições chaves no CLAUDE.md.
Exploração	Envia o comando de modificação no primeiro prompt sem contexto.	Bloqueia alterações iniciais e instrui a IA a analisar o funcionamento e falhas do arquivo.
Planejamento	Permite que a IA comece a reescrever arquivos sem expor a proposta.	Solicita a proposta por escrito ou usa o plan mode (Shift+Tab) para alinhar a lógica antes de codificar.
Execução	Aprova blocos de diff sem conferir as linhas alteradas.	Analisa cada diff no console para garantir que o escopo de alteração corresponda ao planejado.
Validação	Acredita na mensagem da IA que diz que o código está funcionando.	Executa cenários de sucesso, erro e regressão localmente para garantir o funcionamento.
Entrega	Mantém alterações soltas no repositório sem controle de versão.	Confirma os arquivos modificados e comita localmente com mensagens claras.

Adote as etapas do fluxo profissional como diretrizes de desenvolvimento diário. Elas garantem maior estabilidade e eficiência ao interagir com a IA.

💡 Resumo em uma frase: O desenvolvimento com IA alcança maior eficiência através de etapas claras de planejamento, revisão e testes práticos locais, mitigando falhas geradas por pressa ou falta de contexto.

---

11 Resumo

Neste capítulo, reunimos as técnicas aprendidas para guiar um ciclo prático de desenvolvimento de software em seis etapas, aplicando regras do CLAUDE.md, plan mode, leitura de diffs, validação e Git.

Revisão das etapas do fluxo:

Etapa	Ação Executada	Recurso Aplicado	Objetivo
Abertura	Iniciar console e CLAUDE.md	Capítulos 2, 12 e 18	Estabelecer a base do projeto e restrições
Exploração	Pedir análise do arquivo sem edições	Capítulo 16	Garantir a compreensão da estrutura do código
Planejamento	Validar a lógica de implementação	Capítulo 20 (plan mode)	Alinhar a solução e prever falhas de lógica
Execução	Aprovar modificações avaliando diffs	Capítulo 20 (permissões)	Monitorar linhas escritas e evitar alterações extras
Validação	Executar testes práticos locais	Capítulo 16	Garantir o funcionamento dos cenários e compatibilidade
Entrega	Salvar commits de alteração local	Capítulo 7	Consolidar o código funcional no Git

Agora você é capaz de: gerenciar com maturidade o ciclo de desenvolvimento de novas demandas usando IA, estruturar arquivos CLAUDE.md objetivos para guiar o contexto da sessão, bloquear alterações para alinhar propostas de lógicas previamente, ler e aprovar diffs com olhar crítico no terminal, testar implementações localmente e consolidar alterações no Git de forma segura. Isso torna o processo de programação mais produtivo.

Com o fluxo de desenvolvimento consolidado, avançamos na interação com sistemas externos.

---

O próximo capítulo, 40 "Chrome: Operando o Navegador", ensinará a dar ao Claude a capacidade de interagir com o navegador de internet. Veremos como configurar e permitir que a IA abra o Chrome, clique em elementos da página, preencha formulários e capture dados de aplicações web, permitindo automatizar validações visuais e de front-end. Nos vemos no próximo capítulo!

---

Leituras Recomendadas

• Trabalhando com o JetBrains
• Gerenciando Estilos de Saída de Console
• Padrões de Fluxos Comuns no Desenvolvimento