Qual o melhor modelo de IA com grande contexto para refatorar C# de .NET 4.8 para .NET 10
TL;DR
- Janela grande não é luxo — refatorar .NET 4.8 → .NET 10 exige enxergar `.csproj`, `web.config`, controllers, repositórios e classes de domínio no mesmo prompt.
- Nuvem (Claude, Gemini) entrega 1M a 2M de tokens e visão holística do repositório, mas o código sai do hardware da empresa.
- Local (Ollama com Qwen3-Coder, Devstral, DeepSeek-R1) mantém o código proprietário no hardware da empresa, com janelas de 32K a 256K e custo zero de API após setup.
- Estratégia híbrida vence: nuvem para análise e plano arquitetural, local para refatoração módulo a módulo sem expor código sensível.
- Qwen3-Coder 30B via Ollama é o campeão local em C# para 2026, segundo benchmarks de campo; Claude Sonnet 4.6 vence em nuvem para repositórios acima de 500K LOC.
O que muda na migração .NET Framework 4.8 → .NET 10.0
A migração não é uma atualização. É um conjunto coordenado de substituições que a ferramenta de IA precisa enxergar em conjunto, sob pena de introduzir regressões silenciosas.
Formato de projeto: o `.csproj` legado é XML denso com referências inline a cada assembly. O formato SDK-style consolida tudo em propriedades globais e `
Pipeline HTTP: `System.Web.HttpModule`, `HttpHandler` e o ciclo de vida herdado do ASP.NET clássico somem. O ASP.NET Core substitui por middleware tipado com `RequestDelegate`. A migração exige mapear cada handler legado para o middleware correspondente, preservando o invariante de autenticação e de cabeçalhos que ele garantia implicitamente.
Configuração: `ConfigurationManager.AppSettings` e `ConnectionStrings` (lidos de `web.config` em runtime) viram `IConfiguration` (lido de `appsettings.json` no startup e injetado via DI). A IA que ignora essa mudança deixa o código novo sem acesso às chaves de configuração — falha em produção, passa no build local.
Entity Framework: o EF6 legado, com herança de `DbContext` atrelada a `IDbSet
Injeção de dependência: o .NET 10 traz DI nativa via `Microsoft.Extensions.DependencyInjection`. Containers antigos da era .NET Framework (Unity, Autofac com XML config, StructureMap) viram desnecessários ou opcionais. Reescrever o registro dos serviços é parte obrigatória da migração.
A IA com janela pequena consegue refatorar um único controller. A IA com janela grande consegue refatorar a cadeia controller → serviço → repositório → contexto preservando o contrato.
Modelos em nuvem: precisão e janelas gigantes
A categoria nuvem tem como vantagem o orçamento de hardware: provedores como Anthropic, Google e DeepSeek rodam os modelos em clusters de GPU que custam dezenas de milhões de dólares. O resultado prático é que os modelos hospedados superam qualquer configuração local equivalente em janela de contexto e em latência amortizada.
Claude (Sonnet 4.6 e Opus 4.5) — janela de 1 milhão de tokens
A Anthropic oferece até 1 milhão de tokens de contexto. Para um repositório de médio porte, isso é o suficiente para passar o `.sln` inteiro, todas as dependências e a configuração em um único prompt. Em benchmark de campo publicado em maio de 2026, o Sonnet 4.6 atinge taxa de acerto de 88% em refatoração multi-arquivo em C# quando recebe o repositório completo como contexto. O Opus 4.5 sobe para 93%, ao custo de maior latência por token.
A escolha do Claude é recomendada quando: o repositório tem mais de 500K LOC, a refatoração precisa preservar invariantes de negócio documentadas em comentários, e a auditoria de compliance aceita envio do código para API terceirizada sob contrato de NDA.
Google Gemini (Pro 2.5 e Flash 2.5) — janela de 2 milhões de tokens
O Gemini Pro 2.5 atinge 2 milhões de tokens. Em sistema monolítico muito grande, é o único modelo que cabe o `.sln` inteiro sem necessidade de pré-filtragem. A precisão em C# é ligeiramente inferior ao Claude Sonnet 4.6 (82% vs 88% no mesmo benchmark), mas a janela mais larga reduz a chance de o modelo perder dependência cruzada entre módulos distantes.
A escolha do Gemini é recomendada quando: o repositório passa de 1M LOC, o custo por token é fator crítico, e a latência tolerada é inferior a 30 segundos por chamada.
DeepSeek V3.2 (cloud API) — janela de 128K com custo-benefício superior
O DeepSeek V3.2 hospeda API com janela de 128K — menor que Claude e Gemini — mas a um custo por token significativamente inferior (cerca de 1/15 do Claude Opus 4.5). Em tarefas que cabem em 128K, a precisão em C# é equivalente ao Sonnet 4.5. Em tarefas que excedem, o modelo começa a truncar contexto sem aviso explícito.
A escolha do DeepSeek é recomendada quando: o repositório cabe em 128K, o orçamento é apertado, e a latência por chamada não é o gargalo do workflow.
Modelos locais via Ollama: privacidade e custo zero de API
A categoria local é viável em 2026 porque o hardware de consumidor e a engenharia de quantização fecharam a lacuna. Modelos de 30B a 70B em quantização Q4 rodam em GPU de 24GB a 48GB de VRAM com latência aceitável para refatoração iterativa. O custo fixo é o hardware; o custo marginal por token é zero.
Qwen3-Coder 30B (MoE) — o estado da arte aberto em C#
O Qwen3-Coder 30B é uma mistura de especialistas com 3B de parâmetros ativos por inferência. Janela de contexto nativa de 256K tokens, expansível com ajuste fino de RoPE. Em benchmark de campo publicado em abril de 2026, atinge 85% de acerto em refatoração C# — 3 pontos percentuais abaixo do Claude Sonnet 4.6, mas com a vantagem de o código nunca sair do hardware local.
# Setup básico
ollama pull qwen3-coder:30b
# Verificar modelo
ollama listA escolha do Qwen3-Coder é recomendada quando: a política de segurança da empresa proíbe envio de código a APIs externas, o hardware disponível é RTX 4090 ou superior, e a precisão próxima de 85% é suficiente para o trabalho (o resto fica com revisão humana).
Devstral 24B (Mistral AI) — agente local de código
O Devstral 24B é um modelo ajustado para uso como agente de software. Janela de 128K, aderência alta a instruções estruturadas, e suporte nativo a tool use — o que permite fluxo de “leio arquivo → edito arquivo → rodo teste” sem orquestração externa.
ollama pull devstral:24bA escolha do Devstral é recomendada quando: o workflow de refatoração é iterativo (múltiplas passadas no mesmo arquivo) e a integração com ferramentas externas (linter, test runner) é parte do pipeline.
DeepSeek-R1 Distill 32B / 70B — raciocínio passo a passo
O DeepSeek-R1 Distill é o raciocínio passo a passo destilado para caber em hardware local. Janela de 64K, latência alta (cada token demanda mais computação por ser modelo de raciocínio), mas a vantagem aparece em tarefas onde a IA precisa explicar o porquê da mudança antes de executar — útil quando a equipe precisa de documentação da decisão de refatoração.
ollama pull deepseek-r1:32bA escolha do DeepSeek-R1 é recomendada quando: a equipe de revisão exige explicação textual da mudança proposta, e a latência adicional é aceitável no fluxo de trabalho.
Tabela comparativa: nuvem vs local
| Critério | Nuvem (Claude / Gemini) | Local via Ollama (Qwen3-Coder / Devstral) |
|---|---|---|
| Janela de contexto | 1M a 2M de tokens (repositório inteiro cabe) | 32K a 256K de tokens (módulo por módulo) |
| Privacidade do código | Enviado para API terceirizada (exige contrato) | 100% local, código nunca sai do hardware da empresa |
| Hardware necessário | Apenas conexão à internet | GPU dedicada 24GB+ VRAM (RTX 4090 / A5000 / equivalente) |
| Custo por token | Pago por milhão de tokens consumidos | Zero de API; custo fixo de hardware e eletricidade |
| Latência por chamada | 5 a 30 segundos (depende da fila do provedor) | 1 a 10 segundos por requisição (depende da GPU) |
| Precisão em C# | 88% a 93% (Sonnet 4.6 / Opus 4.5) | 80% a 85% (Qwen3-Coder 30B / Devstral 24B) |
| Adequação a LGPD | Exige DPA e classificação de dados | Sem implicações contratuais |
| Independência de provedor | Alta (trocar de provedor muda contrato) | Total (modelo roda offline) |
Estratégia recomendada para refatoração
A escolha binária obscurece o ganho real, que está em combinar as duas modalidades em fases distintas do trabalho.
Fase 1 — Análise arquitetural (nuvem)
A primeira fase é entender o sistema como um todo. Aqui a janela grande da nuvem é decisiva. Carregar o `.sln` inteiro, todas as `packages.config`, todas as `web.config` e gerar o plano de migração: ordem dos módulos a refatorar, dependências circulares a quebrar, invariantes a preservar. A saída dessa fase é um documento Markdown com a sequência de trabalho e os pontos de risco. Esse documento é o que guia as fases seguintes.
Fase 2 — Refatoração módulo a módulo (local)
A segunda fase é execução. Cada módulo (controller, repositório, serviço) é refatorado isoladamente, em janela menor, com modelo local. O código nunca sai do hardware. A revisão humana completa cada módulo antes de avançar para o próximo. A latência de iteração é menor (modelo local responde em 1-10 segundos) e o custo é zero.
Fase 3 — Integração e testes (qualquer modelo)
A terceira fase é garantir que o sistema refatorado se comporta como o legado. Aqui o modelo é menos importante que o rigor: suite de testes de regressão, canary deployment, observability. O modelo entra apenas para diagnóstico de regressões específicas.
O prompt base para a fase 2, validado em campo:
> Atue como arquiteto .NET sênior. Converta o código C# abaixo, escrito para .NET Framework 4.8 com Entity Framework 6 e System.Web, para .NET 10.0 com C# 13/14, Entity Framework Core, injeção de dependência nativa em Microsoft.Extensions.DependencyInjection, e async/await em todo o pipeline de I/O. Identifique dependências obsoletas e proponha substituto NuGet equivalente. Preserve nomes de classes públicas e contratos de API. Comente o código migrado explicando cada decisão não trivial.
Esse prompt, isolado em janela local, processa controller por controller preservando o contrato da camada de serviço. A revisão humana completa o ciclo.
Conclusão
A janela de contexto grande não é feature opcional para refatoração de sistema legado. É precondição. Sem ela, a IA refatora fragmentos que não conversam entre si; com ela, a IA enxerga o invariante de sistema.
Em 2026, a divisão prática é: Claude Sonnet 4.6 ou Gemini Pro 2.5 para análise e plano; Qwen3-Coder 30B ou Devstral 24B via Ollama para execução. Para empresa com política de privacidade rígida, o Qwen3-Coder 30B local entrega 85% da precisão do Claude a custo zero marginal, em hardware de 24GB de VRAM. Para empresa que pode enviar código sob contrato, o Claude Sonnet 4.6 entrega 88% com janela de 1M de tokens que dispensa fragmentação.
A escolha entre as duas modalidades não é permanente. Sistemas legados grandes demais para a janela local são refatorados em fases, com a nuvem no plano e o local na execução. Sistemas sensíveis demais para a nuvem são refatorados inteiramente no local, com janela menor compensada por iteração humana mais densa.
A pergunta certa não é “nuvem ou local”. A pergunta certa é “em qual fase qual modalidade cobre o trabalho com a melhor razão entre precisão, custo e risco de exposição do código”.
Leitura relacionada
- Programação em par com IA: aceleração evolutiva — define as Quatro Camadas do Trabalho de Desenvolvimento e em que ponto de cada uma a IA acelera versus atrapalha.
- Dependência de IA na revisão de código — o oposto da geração assistida: como a confiança na revisão assistida degrada o julgamento crítico.
- IA programava em 2020. A percepção demorou três anos — a defasagem entre a capacidade técnica e a narrativa pública sobre o que a IA já faz em código.
1 Comentário