Codificação assistida por IA – kirit.com

Criado em 2026-02-27T05:33:43.558Z, última edição em 2026-03-07T08:06:06.304Z

Eu tenho experimentado um pouco IA codificação assistida. Por recomendação de um amigo, atualmente estou usando os modelos GLM 4.7 e 5 da Z.ai com os do Claude CLI ferramentas.

E apesar de tudo, gosto bastante.

Já faz algum tempo que uso interfaces de bate-papo para ajudar em algumas coisas, especialmente na depuração de código Vulkan, e tenho achado isso bastante útil – principalmente o LLMParece que temos uma compreensão muito melhor do Vulkan do que eu.

Na parte de algum código do jogo em que estou trabalhando no momento, o jogador precisa escolher uma recompensa ao subir de nível. Isto requer uma nova caixa de diálogo modal que pergunta ao jogador quais das opções oferecidas ele deseja aceitar. Eu já tinha feito o código que definia quais opções oferecer, então agora precisava do código que pedia ao jogador.

Há muita configuração em algo assim, então pedi à IA para fazer isso por mim. Eu disse que queria um novo arquivo para o modal de subida de nível e esperei para ver o que acontecia. E realmente me surpreendeu ao inventar algo estruturalmente quase idêntico ao que eu teria feito. Para fazer isso, foi necessário:

• Descubra como funcionava a sinalização de que o jogador havia subido de nível e onde as escolhas apareciam no sinal.
• Descubra como fazer a interface de uma corrotina que aguarda esse sinal necessário para fazer a interface com a sinalização de nível de que um novo modal era necessário.
• Descubra como implementar o novo modal, incluindo como funcionava o código de layout da UI que escrevi no jogo.
• Descubra como o desenho do modal teve que interagir com o loop de renderização para que fosse desenhado até que o jogador fizesse uma escolha.

Francamente eu estava dolorido espantado.

Tive alguns problemas: não gostei de alguns dos nomes que ele usou, esqueci de adicionar o novo arquivo ao cmake e conectou a solicitação do modal a uma corrotina existente que mostrava notificações ao subir de nível. Quando solicitado, ele criou uma nova rotina para mim e descobriu corretamente quando e onde iniciá-la. Eu rapidamente consertei as outras coisas que não gostei.

Depuração

Hoje eu estava continuando com esse trabalho e percebi que o jogo estava oferecendo o mesmo upgrade de dano tanto para as torres do parafuso quanto para o trator, o que não fazia sentido. Esse tipo de depuração pode ser rápida ou lenta, pois há muitos lugares onde o erro pode estar. Então, outra tarefa perfeita para a IA?

E de fato encontrou o bug muito rapidamente. O código ficou assim:

void core::component::turret::improvements(
        gamedata::rarity::ref rarity,
        gamedata::projectile::improvement::pool &pool) const {
    auto const &pc = (&)() -> gamedata::projectile::ref {
        switch (weapon->configuration.projectile) {
        case gamedata::projectile::type::bolt:
            return gamedata::projectile::definition::named("bolt");
        case gamedata::projectile::type::tractor:
            return gamedata::projectile::definition::named("bolt");
        }
    }();
    for (auto const &i : pc.configuration.improvements.at(rarity)) {
        pool.push_back(i);
    }
}

É claro que me senti muito tolo por ter cometido um erro tão óbvio de copiar e colar, mas acho que esses tipos de bugs costumam ser os mais difíceis de encontrar, simplesmente porque fazem tão pouco sentido.

Quando pedi uma correção à IA, ela sugeriu simplesmente corrigir o erro de digitação, o que é claro que rejeitei:

● Update(src/core/components.cpp)
  ⎿  User rejected update to src/core/components.cpp
      290          case gamedata::projectile::type::bolt:
      291              return gamedata::projectile::definition::named("bolt");
      292          case gamedata::projectile::type::tractor:
      293 -            return gamedata::projectile::definition::named("bolt");
      293 +            return gamedata::projectile::definition::named("tractor");
      294          }
      295      }();
      296      for (auto const &i : pc.configuration.improvements.at(rarity)) {

Passei a maior parte dos últimos trinta anos orientando colegas sobre práticas e artesanato de desenvolvimento de software, e esse é exatamente o tipo de mudança que esperaria de um desenvolvedor júnior. Eles sempre optarão pela solução simples e óbvia, em vez de levar em consideração qualquer consideração mais ampla – os juniores, como os LLMs, não têm medo do volume de código – e se uma mudança em um lugar exigir também uma mudança em outro lugar, bem, essas são apenas as regras do jogo. Temos um rótulo para esse tipo de código: dívida técnica.

Eu preferi uma maneira diferente, e a função agora se parece com:

void core::component::turret::improvements(
        gamedata::rarity::ref rarity,
        gamedata::projectile::improvement::pool &pool) const {
    auto const &pc = gamedata::projectile::definition::named(
            gamedata::projectile::to_string(weapon->configuration.projectile));
    for (auto const &i : pc.configuration.improvements.at(rarity)) {
        pool.push_back(i);
    }
}

O futuro?

Quando comecei a programar na década de 1980, tínhamos que escrever em assembly se quiséssemos desempenho. Hoje em dia, quase todos nós escrevemos em linguagens de nível superior e deixamos o compilador cuidar do código de máquina para nós. Não escrevo nenhum assembly desde o início dos anos 90 e, claro, minha produtividade é melhor com isso (mesmo que, às vezes, talvez, eu pudesse fazer um trabalho melhor que o compilador – mas aposto que não com frequência). A verdade é que para a maior parte do código, na maior parte do tempo, isso simplesmente não importa o suficiente.

Superficialmente, o uso da IA ​​parece semelhante. Posso ver um futuro se aproximando rapidamente, onde estou disposto a entregar cada vez mais tarefas ao assistente de IA, mas ainda não vejo que eles não precisarão de ajuda.

A disposição deles de lançar cada vez mais código em um problema até que ele seja resolvido é algo que ainda precisa ser combatido. Tudo o que aprendemos na criação de software ainda é relevante, mesmo nesta nova era.

Por enquanto, pelo menos.

Estamos perdendo alguma coisa. Quando escrevo C++ e deixo o compilador se transformar em código de máquina, este é um processo determinístico e o “prompt” (o C++ original) é obviamente preservado. Ao solicitar uma IA, tudo o que resta é o código e qualquer documentação que a IA escreva para nós. Isso significa que agora estamos lidando com um processo inerentemente com perdas, o que não acontecia antes. Quanto isso vai importar? Na verdade, é muito cedo para dizer, mas minha expectativa é que isso tenha muita importância, especialmente à medida que o volume do código aumenta e a capacidade dos humanos de entendê-lo diminui.

Muitos dos projetos em que trabalhei tiveram o gerenciamento da complexidade como aspecto central do domínio do problema. A questão nunca foi a quantidade de código que poderíamos entregar, a tarefa era descobrir como seria uma solução sustentável para que a complexidade pudesse ser gerenciada, e a solução fosse transparente o suficiente para que todos pudessem entendê-la. Então o código teve que estar em conformidade com essa arquitetura para que ainda estivesse obviamente correto.

A capacidade da IA ​​para ajudar no nosso desenvolvimento está apenas a aumentar, mas ainda vejo um grande papel para os programadores com habilidade para gerir o processo, para que não nos afoguemos num mar de dívidas técnicas.

Adenda

Eu me pergunto se não há aqui um conflito de interesses para as empresas que nos vendem acesso aos modelos de codificação. Quanto mais código tivermos que manter, mais teremos que pagar pelo processamento de tokens, mais teremos que pagar para atualizar para modelos com janelas de contexto cada vez maiores e mais GPUs e data centers serão necessários. Quanto mais nos afogamos em dívidas técnicas, mais temos de lhes pagar para tentarem emergir. Eu me sentiria muito mais feliz se nossos objetivos financeiros estivessem melhor alinhados.

Temos a obrigação ética de ainda cuidar de nosso trabalho e tornar o código o melhor possível usando nossas métricas mais tradicionais? Há uma responsabilidade federal clara para os gestores das empresas que utilizam assistência de IA (estou pensando particularmente nas empresas não tecnológicas que contratam desenvolvedores), mas isso só pode se tornar aparente depois que a maioria dos engenheiros de software partir e apenas as empresas de IA sobrarem.