Claude Code - Dicas de Fluxo de trabalho

Hoje veremos algumas dicas de como ter mais produtividade e extrair mais do Claude Code no dia a dia

A seguir vou apresentar sete dicas para otimizar o fluxo de trabalho usando o Claude Code.

1. Inicie o projeto com o comando /init para criar o contexto do projeto para o Claude

Uma das primeiras coisas a se fazer ao começar a trabalhar em um novo projeto é enviar o comando ao Claude Code:  /init

O Claude criará um arquivo CLAUDE.md com informações contextuais sobre este projeto específico.

Como exemplo vemos o arquivo CLAUDE.md gerado para a execução do comando  /init em um projeto Blazor Web App de controle financeiro:

# CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with 
code in this repository.

## Project status

This is a Blazor Server (.NET 9) application scaffolded from the default 
`dotnet new blazor` template. It is named "ControleFinanceiro" (personal 
finance management, per the project name) but no domain-specific functionality 
has been built yet — all files under `Components/` are still the template's stock
 pages (Home, Counter, Weather, layout, routing).

## Commands

Run all commands from the repository root (`D:\projetos\controlefinanceiro`), 
where `ControleFinanceiro.sln` / `ControleFinanceiro.csproj` live.

- Build: `dotnet build`
- Run (dev server with hot reload): `dotnet watch run`
- Run (no watch): `dotnet run`
- Restore packages: `dotnet restore`

There is no test project in the solution yet. When adding tests, create a separate 
test project (e.g. `ControleFinanceiro.Tests`) and add it to `ControleFinanceiro.sln`;
 standard command would then be `dotnet test`.

Dev server ports (from `Properties/launchSettings.json`):
- HTTP: `http://localhost:5210`
- HTTPS: `https://localhost:7245`

## Architecture

- **App model**: Blazor Server with interactive server-side render mode, configured 
in `Program.cs` via `AddRazorComponents().AddInteractiveServerComponents()` 
and `MapRazorComponents<App>().AddInteractiveServerRenderMode()`. 
All UI runs as server-rendered Razor components with a SignalR circuit 
— there is no WebAssembly/client-side component host set up.

- **Entry point**: `Program.cs` builds the `WebApplication`, wires the exception 
handler + HSTS for non-Development environments, and maps static assets + root 
component `App`.

- **Root composition**: `Components/App.razor` is the HTML shell (doctype, head, 
`<Routes />`, blazor.web.js). `Components/Routes.razor` sets up the `Router` over
 the assembly. `Components/_Imports.razor` holds shared `@using` directives for all 
`.razor` files.

- **Layout**: `Components/Layout/MainLayout.razor` + `Components/Layout/NavMenu.razor`
 define the page chrome and left nav.
- **Pages**: `Components/Pages/*.razor` — each page is a routable component 
(`@page` directive at the top). Currently only the template samples (`Home`,
 `Counter`, `Weather`, `Error`) exist.

- **Static assets**: served from `wwwroot/`, referenced in markup via the 
`Assets[...]` map (ASP.NET Core's asset fingerprinting), e.g. `@Assets["app.css"]`.

- **No data layer yet**: no `DbContext`, no EF Core package reference, no services 
registered beyond Razor Components. When adding persistence or business logic for 
finance tracking, this is greenfield — there's no existing pattern in-repo to conform
 to yet, so establish one deliberately (e.g. a `Services/` or `Data/` folder, DI 
registration in `Program.cs`).

Depois você pode otimizar o CLAUDE.md gerado refinando o seu conteúdo.

2. Use o modo "Plan" (Planejamento) para qualquer tarefa complexa.

Não parta direto para a implementação. Em vez disso, crie o contexto adequado para que a IA gere o melhor resultado possível.

No modo "Plan" antes de escrever uma única linha de código, o Claude elabora um plano que explica sua abordagem e faz perguntas importantes a você. Isso me poupa de muitas idas e vindas.

Uma dica valiosa para o planejamento com o Claude Code:

Use o Codex para o planejamento.

Dois modelos são melhores do que um. E o grande diferencial do Claude Code é que você pode integrar o Codex ao seu ambiente do Claude. Para isso, você precisará instalar o plugin do Codex:

/plugin install codex@openai-codex

Assim, você pode usar o Codex para revisar o plano do Claude antes da implementação, utilizando o seguinte comando:

/codex:adversarial-review

Uma revisão feita por outra IA (de confronto crítico) identificará diversos problemas no plano, poupando muitos tokens que, de outra forma, seriam gastos em iterações desnecessárias.

3. Comece pequeno

Ao trabalhar no design de um novo produto, raramente construímos o produto inteiro de uma só vez. Na maioria das vezes, dividimos uma tarefa grande (criar um novo produto) em subtarefas e as executamos uma a uma. A mesma abordagem se aplica ao trabalho com IA.

Se você pedir ao Claude para "implementar o produto inteiro", ele o fará, mas há uma grande chance de que muitas áreas desses novos recursos exijam refinamento e iterações adicionais. Ao lidar com tarefas menores, você reduz a probabilidade de enfrentar problemas.

Como exemplo se você tentar fazer tudo de uma vez para criar um projeto de Pedidos com ASP.NET Core usando o prompt:

"Crie o sistema completo de Pedidos com banco de dados, injeção de dependência, validações e o Factory Method."

O Claude vai gerar dezenas de arquivos, mas a chance de você ter problemas com namespaces errados, métodos faltando ou erros de compilação é enorme.

A aplicação prática dessa dica é quebrar isso em 3 passos cirúrgicos:

Passo 1: Focar apenas no Domínio (As Regras e a Factory)

Primeiro, você isola a lógica pura do C#, sem se preocupar com Web API ou banco de dados.

O seu comando para o Claude:

"Claude, crie apenas a interface IPedido, as classes PedidoNacional e PedidoInternacional, e a classe abstrata PedidoFactory com suas respectivas implementações. Não crie controllers ou endpoints ainda."

Você compila, vê se a lógica da Factory faz sentido e se o C# não acusa erros.

Passo 2: Focar na Integração (A Web API)

Com a Factory funcionando e testada no domínio, você passa para a camada de exposição.

O seu comando para o Claude:

"Agora que a Factory está pronta, crie o PedidosController (ou uma Minimal API) que receba essa Factory via Injeção de Dependência e exponha um endpoint POST /api/pedidos para criar os pedidos."

Você roda o projeto, abre o Swagger e testa se o endpoint está respondendo corretamente.

Passo 3: Focar na Persistência (O Banco de Dados)

Por fim, você adiciona a infraestrutura que faltava.

O seu comando para o Claude:

"O endpoint está funcionando com dados em memória. Agora, configure o DbContext do Entity Framework Core para salvar esses pedidos gerados pela Factory no banco de dados."

Por que isso funciona melhor?

Se der um erro no Passo 2, você sabe com 100% de certeza que o problema está na rota ou na injeção de dependência da API, e não na lógica da Factory (que já foi validada no Passo 1). Fica infinitamente mais fácil debugar.

Dica valiosa para otimizar o trabalho com o Claude Code:

Use uma prévia visual da sua solução.

Uma grande vantagem do Claude Code é que ele pode exibir uma prévia do seu futuro produto. É possível até pedir ao Claude Code para mostrar uma parte específica do produto, caso você queira entender como ela funciona.

Por exemplo, você pode pedir ao Claude Code para visualizar um novo recurso do produto dentro do contexto de um fluxo de usuário específico. O melhor de tudo é que o protótipo não precisa ser criado na mesma pilha tecnológica do seu aplicativo; você pode pedir ao Claude Code para criar um protótipo simples em HTML para testar o recurso.

Como exemplo, suponha que você esta implementando o padrão factory method em um projeto de Pedidos (ASP.NET Core Web API)

Como eu faria para ele me mostrar a visualização final disso ?

Para ver a visualização funcional da sua fábrica no ASP.NET Core sem precisar criar todo o banco de dados ou a interface definitiva, a melhor estratégia é pedir ao Claude Code para gerar um mecanismo de teste rápido (Console ou Minimal API) que isole e simule a criação dos objetos.

Como o Claude Code lê a estrutura do seu projeto, você pode pedir para ele simular os diferentes cenários. Veja o passo a passo de como fazer isso na prática utilizando a ferramenta:

Passo 1: O Comando no Claude Code

No terminal onde o Claude Code está rodando, você deve pedir para ele criar um cenário de teste visual isolado. Digite algo como:

"Claude, crie uma Minimal API temporária (ou um program de console) que utilize o meu Factory Method de Pedidos. Quero que ela simule a criação de 3 tipos de pedidos diferentes e retorne o resultado formatado em JSON na tela para eu validar o comportamento visual final."

Passo 2: O que o Claude Code vai estruturar

Ele vai entender o seu padrão Factory. Imagine que você tem uma estrutura parecida com esta no seu projeto:

// O produto que sua fábrica cria
public interface IPedido { string Processar(); }

// As implementações reais
public class PedidoNacional : IPedido { public string Processar() => 
               "Pedido Nacional processado via Frete Padrão."; }

public class PedidoInternacional : IPedido { public string Processar() => 
          "Pedido Internacional processado via DHL com taxas alfandegárias."; }

// A Fábrica (Factory Method)
public abstract class PedidoFactory 
{
    public abstract IPedido CriarPedido();
}

 Para te dar a visualização final, o Claude Code criará um arquivo de teste rápido (como um endpoint direto no seu Program.cs ou um arquivo factory-test.http).

Ele simulará a execução criando um endpoint visual assim:

// Endpoint temporário que o Claude pode injetar para você visualizar
app.MapGet("/visualizar-factory/{tipo}", (string tipo) => 
{
    PedidoFactory factory = tipo.ToLower() switch
    {
        "nacional" => new NacionalFactory(),
        "internacional" => new InternacionalFactory(),
        _ => throw new ArgumentException("Tipo inválido")
    };

    IPedido pedido = factory.CriarPedido();

    // O retorno visual imediato
    return Results.Ok(new {
        Cenario = $"Simulação de Pedido {tipo}",
        ResultadoFactory = pedido.Processar(),
        TipoObjetoCriado = pedido.GetType().Name,
        Timestamp = DateTime.UtcNow
    });
});

Passo 3: Como você visualiza o resultado?

Uma vez que o Claude Code gerar esse trecho de teste, você tem duas formas excelentes de enxergar o resultado final:

Opção A: Via arquivo .http (A mais limpa)

Você pode pedir: "Claude, crie um arquivo teste.http para disparar requisições contra essa factory".

Ele gerará um arquivo no seu projeto. Se você usa o VS Code ou Visual Studio, basta clicar em "Send Request" diretamente no arquivo para ver a resposta formatada ao lado:

Resultado visual que você verá na tela:

Opção B: Via Swagger UI

Como você está em uma ASP.NET Core Web API, se o Swagger estiver ativo, você pode simplesmente pedir para o Claude rodar o projeto (dotnet run). Abra o navegador no endereço do Swagger (http://localhost:XXXX/swagger) e você verá o endpoint da Factory pronto para ser testado com um clique no botão "Try it out".

Dica de ouro com o Claude Code:

Se você não quiser mexer em nada do código do seu projeto atual para não "sujar" o repositório, peça expressamente: "Claude, crie um arquivo FactorySimulacao.cs isolado com um método Main contendo um protótipo em texto limpo rodando essa lógica, e execute-o via terminal para mim". Ele rodará e te mostrará o fluxo printado no próprio terminal da ferramenta.

4. Não tente explicar bugs com suas próprias palavras

Quando o Claude gerar um design para você e você se deparar com um erro durante a interação com seu produto, não tente explicar o problema usando suas próprias palavras.

Em vez disso, copie e cole o código de erro e peça ao Claude para corrigir a falha. O Claude foi treinado com uma enorme base de dados de códigos de erro; muitas vezes, é muito mais fácil para a IA identificar a causa raiz do problema quando você fornece o código de erro bruto.

Dica valiosa: Peça ao Claude para realizar uma auditoria de segurança no seu código-fonte.

O fato de o produto funcionar conforme o esperado não significa que ele seja seguro para uso. É sempre recomendável realizar uma auditoria de segurança antes de lançar um produto.

Vamos a um exemplo prático de como aplicar essa dica em um projeto ASP.NET Core / .NET 8 ou 9, dividida em duas partes: o erro bruto e a auditoria de segurança.

Parte 1: Aplicando a regra do "Erro Bruto"

Imagine que você tentou rodar sua API de Pedidos após implementar o Factory Method e o terminal cuspiu este erro gigante e intimidador:

❌ O jeito ruim (Explicando com suas palavras):

"Claude, deu um erro de InvalidOperationException dizendo que não conseguiu resolver o serviço da minha factory no controller de pedidos quando fui rodar a API. Arrume para mim."

O jeito certo (Copiar o erro bruto):

Você joga o erro exatamente como está e digita apenas:

"Claude, montei a factory de pedidos mas ao rodar a API deu este erro. Corrija o código:" [Colar o erro bruto no terminal do Claude Code]

O que o Claude identifica imediatamente no erro .NET:

Ao ler Unable to resolve service for type..., o Claude não precisa adivinhar. Ele vai direto na raiz do ecossistema .NET: você esqueceu de registrar sua Factory no container de Injeção de Dependência (DI) do ASP.NET Core.

Ele te devolverá o ajuste exato para o seu Program.cs:

Parte 2: A Dica de Ouro (Auditoria de Segurança no .NET)

Como o texto mencionou, o fato de a Factory estar funcionando e criando pedidos não significa que ela é segura. No .NET, falhas de segurança comuns envolvem injeção de dados ou exposição de estados.

Veja um exemplo de código que funciona perfeitamente, mas falharia feio em uma auditoria de segurança que você pediria ao Claude:

public class PedidoFactory 
{
    // O código funciona, mas tem uma falha grave de segurança (.NET SQL Injection)
    public IPedido CriarPedidoPorQueryString(string tipoPedido, string conexaoBanco)
    {
        // VULNERABILIDADE: Concatenando string diretamente para buscar regras no banco
        string query = $"SELECT * FROM RegrasPedidos WHERE Tipo = '{tipoPedido}'";

        // Executa a query...

        if (tipoPedido == "Internacional") return new PedidoInternacional();
        return new PedidoNacional();
    }
}

Como pedir a auditoria ao Claude:

Você envia sua Factory e escreve:

"Claude, esta Factory de Pedidos está funcionando perfeitamente nos meus testes de endpoint. No entanto, realize uma auditoria de segurança estrita focada em vulnerabilidades comuns do ecossistema .NET (OWASP Top 10, SQL Injection, Resource Leak) neste trecho e reescreva-o com as correções."

O Diagnóstico que o Claude retornará:

O Claude identificará que a interpolação de string '{tipoPedido}' abre as portas para um ataque de SQL Injection. Se um usuário passar no parâmetro da API algo como Nacional'; DROP TABLE RegrasPedidos; --, ele pode apagar seu banco de dados.

Ele reescreverá o código utilizando Consultas Parametrizadas (via Dapper ou ADO.NET) ou o ecossistema seguro do Entity Framework Core:

// Código corrigido pelo Claude após a auditoria
public async Task<IPedido> CriarPedidoSeguroAsync(string tipoPedido, MyDbContext context)
{
    // O EF Core parametriza isso automaticamente, tornando-o imune a SQL Injection
    var regra = await context.RegrasPedidos
        .FirstOrDefaultAsync(r => r.Tipo == tipoPedido);

    if (tipoPedido == "Internacional") return new PedidoInternacional();
    return new PedidoNacional();
}

5. Transferir o contexto para a sessão quando você se deparar com o excesso de contexto

Se você precisar iniciar uma nova sessão devido ao excesso de contexto e não quiser perder detalhes contextuais importantes, você pode pedir ao Claude Code para criar um dump com essas informações.

Aqui está uma recomendação de prompt:

"Quero iniciar uma nova sessão e preparar todas as informações necessárias para isso antes de encerrar a sessão atual."

O Claude salvará os detalhes da sessão no arquivo MEMORY.md.

6. Execute /simplify antes de revisar o código-fonte

O Claude tende a complicar excessivamente a implementação, escrevendo mais código — e código mais complexo — do que o necessário. Este comando

/simplify

fará com que o Claude Code revise e otimize o código-fonte antes da revisão manual.

No ecossistema .NET, isso se traduz em um Claude que cria interfaces desnecessárias, estruturas de herança complexas para problemas simples, ou blocos gigantescos de LINQ difíceis de ler.

Abaixo, veja os detalhes de como esse comando funciona na prática, o que ele faz nos bastidores e um exemplo real em C#.

O que o /simplify faz nos bastidores?

Quando você executa esse comando antes de começar a revisar manualmente ou implementar uma nova feature, você força o Claude Code a aplicar um "filtro de navalha de Ockham" no arquivo. Ele realiza três ações principais:

- Ele elimina código redundante, variáveis temporárias desnecessárias e estruturas de controle (if/else) excessivamente aninhadas.

- No .NET, ele converte sintaxes antigas para recursos modernos do C# (como Pattern Matching, Primary Constructors, Switch Expressions e Target-typed new expressions), que reduzem drasticamente as linhas de código mantendo a legibilidade.

-  Se uma função estiver tentando fazer três coisas ao mesmo tempo, o comando a quebra ou enxuga para que ela faça apenas o essencial.

Exemplo Prático: O "Efeito Claude" no .NET

Imagine que você pediu para o Claude criar um validador simples para o seu fluxo de Pedidos. Por padrão (tendendo à superengenharia), ele pode te entregar algo assim:

❌ O código gerado inicialmente pelo Claude (Overengineering ou Superengenharia)

public class ValidadorPedido
{
    public bool ValidarPedidoParaProcessamento(Pedido pedido)
    {
        if (pedido == null)
        {
            throw new ArgumentNullException(nameof(pedido), "O pedido não pode ser nulo.");
        }

        bool resultadoStatus = false;
        if (pedido.Status == StatusPedido.Pendente)
        {
            resultadoStatus = true;
        }
        else
        {
            resultadoStatus = false;
        }

        bool resultadoItens = false;
        if (pedido.Itens != null && pedido.Itens.Count > 0)
        {
            resultadoItens = true;
        }

        if (resultadoStatus == true && resultadoItens == true)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

O código acima funciona perfeitamente, mas é verboso, cheio de flags booleanas desnecessárias e difícil de bater o olho e entender instantaneamente.

Se você rodar o comando no terminal do Claude Code apontando para essa classe, ele reescreverá o código aplicando as melhores práticas de concisão do C# moderno:

public class ValidadorPedido
{
    public bool ValidarPedidoParaProcessamento(Pedido pedido)
    {
        ArgumentNullException.ThrowIfNull(pedido);

        return pedido.Status == StatusPedido.Pendente && pedido.Itens?.Any() == true;
    }
}

O que mudou?

- Substituiu o if (pedido == null) throw... pelo moderno - ArgumentNullException.ThrowIfNull(pedido).
- Eliminou todas as variáveis locais (resultadoStatus, resultadoItens).
- Trocou a verificação manual de contagem da lista pelo método de extensão .Any() com o operador null-conditional (?.).
- Reduziu a lógica complexa de if/else para uma única expressão booleana limpa.

Por que usar ANTES da sua revisão manual?

É muito mais rápido revisar 5 linhas de código limpo do que 30 linhas cheias de blocos repetitivos.

Se você aceitar o primeiro código que o Claude gera, seu projeto começará a inflar muito rápido. Rodar o /simplify garante que apenas a essência do código seja integrada ao seu repositório.

Quando você abrir um Pull Request, sua equipe focará na lógica do negócio implementada, e não em apontar detalhes de sintaxe que poderiam ser mais limpos.

7. Peça ao Claude para resumir a conversa ao final de cada sessão

Assim como as equipes de produto que praticam sprints semanais fazem uma retrospectiva do trabalho após cada sprint, faz sentido realizar uma retrospectiva com o Claude ao final de cada sessão.

Você pode enviar uma mensagem ao Claude:  "O que você aprendeu durante esta sessão? "

Ou criar uma skill específica para o Claude (como uma skill personalizada de /retro) que gere os insights que ele obteve durante a sessão.

Em seguida, você pode analisar e corrigir os insights coletados pelo Claude. Esta é uma ótima maneira de consolidar o conhecimento institucional que o Claude armazena na memória de longo prazo.

Encerramento

A conclusão prática dessas dicas para o seu dia a dia com .NET é uma só: use o Claude Code para o trabalho pesado e objetivo, mas controle o código.

Valide rápido: Use protótipos simples para testar a lógica antes de gastar tempo acoplando tudo na arquitetura do ASP.NET Core.

Seja direto nos erros: Cole o erro bruto do Roslyn ou EF Core sem tentar explicar. A IA resolve mais rápido se ler o código de erro original.

Corte o excesso: Force a simplificação do código. O Claude adora complicar o que o C# moderno resolve em uma linha.

Em resumo: trate a IA como uma ferramenta de execução rápida, passe o filtro da simplicidade e mantenha o foco na segurança.

E estamos conversados...  

"Bendito seja o Deus e Pai de nosso Senhor Jesus Cristo, o Pai das misericórdias e o Deus de toda a consolação"
2 Coríntios 1:3