Copilot ajuda muito, mas você continua 100% responsável pelo seu código .NET

Ferramentas de IA como o GitHub Copilot mudaram completamente a forma como desenvolvemos software em .NET. Elas aceleram tarefas repetitivas, sugerem soluções e podem gerar blocos inteiros de código em segundos.

Mas há uma verdade que muitos desenvolvedores aprendem da pior forma:

Usar IA aumenta sua produtividade, mas não elimina sua responsabilidade.

Isso significa que, mesmo que o código funcione, você ainda precisa revisar, testar e garantir que tudo está correto, seguro e sustentável.

A ilusão da produtividade gratuita

Quando você começa a usar IA diariamente, tudo parece mais rápido:

• Menos tempo escrevendo código de boilerplate
• Respostas instantâneas
• Soluções "prontas para uso"

O problema?

Velocidade sem validação é apenas uma forma mais eficiente de cometer erros.

IA não entende seu sistema, suas regras de negócio ou riscos legais.
Ela apenas prevê o que o código parece correto.
E "parece correto" nem sempre significa é correto.

1. Validar tudo que a IA gera

Código sugerido pela IA não é confiável por padrão.

Exemplo (C# – lógica incorreta para casos de borda)

bool IsEven(double n)
{
    return n % 2 == 0;
}

Console.WriteLine(IsEven(2));   // True
Console.WriteLine(IsEven(2.5)); // False (mas talvez você não esperasse double)

Correção

bool IsEven(int n)
{
    return n % 2 == 0;
}

Explicação: limitar o tipo de entrada evita resultados inesperados.

2. Garantir segurança

Exemplo (SQL Injection)

string query = $"SELECT * FROM Users WHERE Email = '{email}'";
using (var command = new SqlCommand(query, connection))
{
    var reader = command.ExecuteReader();
}

Correção (query parametrizada)

using (var command = new SqlCommand("SELECT * FROM Users WHERE Email = @Email", connection))
{
    command.Parameters.AddWithValue("@Email", email);
    var reader = command.ExecuteReader();
}

Previna ataques de injeção SQL sempre que usar dados de usuário.

3. Entender o que você está usando

Exemplo (embaralhar lista de forma incorreta)

var random = new Random();
var shuffled = list.OrderBy(x => random.Next()).ToList();`

Funciona, mas não é uniformemente aleatório.

Correção (Fisher-Yates shuffle)

void Shuffle<T>(IList<T> list)
{
    var rng = new Random();
    int n = list.Count;
    while (n > 1)
    {
        n--;
        int k = rng.Next(n + 1);
        T value = list[k];
        list[k] = list[n];
        list[n] = value;
    }
}

4. Assumir responsabilidade legal e ética

Exemplo

using SomeUnknownLibrary;

Antes de aceitar uma biblioteca sugerida pela IA, pergunte:

• Qual é a licença?
• Está mantida e atualizada?
• Posso usar em produção legalmente?

Abordagem responsável

• Verificar licença compatível (MIT, Apache, etc.)
• Conferir manutenção e histórico de segurança
• Preferir pacotes confiáveis do NuGet oficial

5. Evitar problemas de performance (N+1 queries)

Exemplo (Entity Framework)

var users = dbContext.Users.ToList();
foreach(var user in users)
{
    var orders = dbContext.Orders.Where(o => o.UserId == user.Id).ToList();
}

Cada usuário gera uma query → problema de performance.

Correção (Include ou batch query)

var usersWithOrders = dbContext.Users
    .Include(u => u.Orders)
    .ToList();

6. Lidar com dinheiro e precisão

Exemplo (float/double para valores monetários)

double price = 0.1;
double tax = 0.2;
double total = price + tax; // 0.30000000000000004`

Correção (decimal)

decimal price = 0.1m;
decimal tax = 0.2m;
decimal total = price + tax; // 0.3`

decimal garante precisão em cálculos financeiros.

IA é copiloto, não piloto

A IA pode sugerir rotas, acelerar decisões e reduzir esforço.

Mas ela não:

• conhece o destino real
• responde por falhas
• lida com consequências

Se você tirar as mãos do volante, isso não é automação é negligência.

Regra prática

Antes de aceitar qualquer código gerado por IA:

Se isso quebrar em produção amanhã, sei exatamente por quê e como corrigir?

Se a resposta for não, você ainda não terminou seu trabalho.

Conclusão

IA não substitui responsabilidade ela a amplifica.

Ela pode tornar você:

• mais rápido
• mais produtivo
• mais eficiente

Mas também pode tornar você:

• mais propenso a erros
• mais exposto a riscos
• mais perigoso como desenvolvedor

No final, nada mudou:

o código é seu.
as decisões são suas.
as consequências também são suas.