A ilusão do Copilot - The Copilot Delusion

 (deplet.ing)
37 pontos por GN⁺ 2025-05-25 | 25 comentários | Compartilhar no WhatsApp
  • A crença de que ferramentas de programação com IA realmente aumentam a produtividade do desenvolvimento é um equívoco
  • Essas ferramentas prejudicam o prazer de programar e a profundidade da compreensão humana
  • A IA pode ser útil para geração repetitiva de código, mas tem fraquezas em contexto, desempenho e nuance
  • A dependência excessiva é um fenômeno que reduz a disposição do desenvolvedor para aprender e explorar, e a qualidade do código
  • O problema do desaparecimento gradual da essência da profissão de programador por causa da conveniência da IA está se tornando maior

Introdução: a ilusão sobre ferramentas de codificação com IA

  • Este texto trata da realidade das ferramentas de geração de código por IA em maio de 2025
  • A controvérsia sobre a incompetência da IA pode enfraquecer com o tempo, mas o problema da destruição da essência e do prazer da programação tende, ao contrário, a se agravar

Capítulo 1: meu colega, o programador

  • O texto usa como exemplo a experiência de trabalhar com desenvolvedores não especializados que copiam e colam código de forma irresponsável, destacando os problemas de piora de desempenho / explosão de bugs / desprezo pela arquitetura deixados por esse tipo de colega
  • Esse tipo de colega modifica código continuamente sem testes, profiling e compreensão de contexto, e no fim acaba roubando a motivação e a vontade de aprender da equipe
  • Por meio da revelação irônica de "Capitão Óbvio", o autor mostra que essa descrição é, na prática, uma sátira às ferramentas de programação com IA como GitHub Copilot e Claude Codex
  • Um verdadeiro copiloto de aeronave entende o sistema como um todo, colabora e assume responsabilidade. Já os AI Copilots deixam apenas código superficial, sem compreensão essencial
  • Pegando emprestado apenas o nome "Copilot", essas ferramentas estão sendo empurradas para a IDE de todo desenvolvedor sob a fachada de produtividade e inovação

Capítulo 2: vantagens do Copilot

  • Ferramentas de programação com IA não são completamente inúteis
  • Elas são úteis para iniciantes aprenderem de forma simples sintaxes complexas de linguagens como C++, ou para consultar conceitos rapidamente
  • Em tarefas como brainstorming, organização de contexto e código de template repetitivo, são mais rápidas e cometem menos erros do que um estagiário humano
  • É evidente, porém, que por não terem qualquer preocupação com desempenho ou eficiência, há o risco de um desastre na qualidade da produção se forem deixadas sem supervisão ao redor
  • Elas podem fornecer rapidamente scaffolds/rascunhos de código sem contexto, mas o design completo e o ajuste fino continuam sendo responsabilidade de desenvolvedores humanos

Capítulo 3: eu como desenvolvedor e a IA

  • O autor valoriza "o prazer de codificar em si" e a sensação de realização de construir algo diretamente
  • Se o código repetitivo (boilerplate) for entregue à IA e a pessoa também desistir de implementar bibliotecas/macros por conta própria, no fim a criatividade e a motivação interna do desenvolvedor desaparecem
  • A dependência do Copilot por FOMO (medo de ficar para trás) acaba levando ao despejo rápido de código tosco e não validado
  • A dependência da IA rouba oportunidades de aprendizado real e de compreensão de desempenho em baixo nível, estrutura e controle de qualidade do código
  • O nome "Copilot" não representa um colega em pé de igualdade, mas sim uma fantasia parecida com a de um gamer com pouca experiência querendo pilotar um avião

Capítulo 4: computador é máquina

  • A capacidade de compreender a realidade e a estrutura da máquina (hardware), e suas características de desempenho existe apenas nos humanos
  • A IA não tem intuição nem experiência direta com cache misses reais, layout de memória, profiling ou gargalos de performance
  • As respostas dadas pela IA estão desconectadas do contexto e, em áreas que exigem otimização específica, são inúteis
  • Mesmo ao criar um aplicativo CRUD comum, o desenvolvedor precisa ter respeito e diligência com os usuários e com o sistema
  • Profissionalismo e espírito artesanal se formam por meio de experiência direta, sofrimento e melhorias repetidas

Capítulo 5: conclusão

  • Ferramentas de programação com IA e sua acessibilidade provocam o desaparecimento do espírito hacker
  • O autor se preocupa com o fenômeno em que apenas usuários passivos, sem interesse genuíno por código, estrutura e desempenho, permanecem na indústria
  • No passado, havia muita curiosidade pura e criatividade, com noites em claro no IRC, experimentos com hardware e exploração de baixo nível
  • Agora, restaram apenas trabalho mecânico e desinteresse, repetindo apenas a "revisão de patches de IA"
  • O texto alerta para o risco de que a geração de código sem compreensão de contexto e sem capacidade real se torne o padrão do setor, e para a realidade em que profissionais realmente competentes acabam sendo excluídos

Histórico de edição do texto

  • Inclusão de um disclaimer sobre a data de redação
  • Esclarecimento da posição sobre o escopo da crítica de desempenho (sistemas complexos vs CRUD), refletindo opiniões do HN
  • Alguns ajustes no estilo das frases e no uso de símbolos para facilitar a leitura

Leituras relacionadas

25 comentários

 
roxie 2025-05-27

O texto é interessante, mas fico um pouco cansado porque parece que muitos artigos podem ser resumidos como: “não usar IA não é a solução para tudo, mas confiar cegamente nela e se deixar domesticar também não é uma boa”..
 
ifmkl 2025-05-26

Os LLMs e a IA vêm evoluindo com o tempo. Há apenas alguns meses, era quase impossível esperar algo como consistência no código do jeito que você pedia, mas agora, dentro desse espaço, se você enviar como arquivos os códigos que a IA gerou a partir das solicitações iniciais de configuração e der a instrução de sempre seguir o estilo de código existente ao escrever código novo, ela acaba produzindo um código bem consistente.
 
crawler 2025-05-26

> Pelo que vi em posts antigos do autor, parece que ele é desenvolvedor de jogos
> Como LLMs não conseguem aprender em grande volume conhecimento ou materiais de desenvolvimento de jogos, ao contrário dos casos de apps CRUD, parece que o autor do texto sente mais claramente as limitações dos LLMs

Li tudo, e no fim acho que o autor acabou ficando com uma visão um pouco enviesada por causa disso.
Claro, fazer como o texto principal diz é algo quase didático e está correto,
mas acho que IA já faz bem o suficiente em CRUD e front-end, onde há muito material para treinar.
Parece que o ideal é aproveitar ao máximo dentro do próprio domínio.
 
superscv 2025-05-26

Acho que há um pequeno mal-entendido sobre o sentido que o autor quis transmitir.
O foco do autor está no desempenho, na estabilidade e em uma arquitetura e consistência de código que facilitem a manutenção dos projetos que ele gerencia, e, em especial, arquitetura e consistência de código são justamente áreas em que os LLMs atuais realmente não são bons.

Especialmente na web, há muita gente entrando em desenvolvimento e uma mentalidade forte de "se funcionar de qualquer jeito, está bom", então uma quantidade enorme de código de baixa qualidade acaba sendo colocada em produção. E como os LLMs foram treinados com base nisso, a qualidade do que eles geram cai a um nível absurdamente ruim.

Simplesmente peça ao GPT: "vou colocar isso no front-end web, então implemente um algoritmo quicksort em JS para mim". Se você não conseguir identificar os problemas na saída, acho que esta conversa não tem muito sentido.
 
ohnul 2025-05-26

Olá. Por curiosidade, tentei dizer: "Vou colocar isso no front-end web, então implemente um algoritmo de quicksort em js". Mas, pelo que vejo, está difícil entender exatamente qual é o problema. Se puderem me explicar, isso me ajudaria muito. Agradeço desde já. https://chatgpt.com/share/68340f9b-b684-8002-8dd5-495d477065cd
 
ohnul 2025-05-26

Parece que o link não está funcionando direito, então estou tentando de novo. https://chatgpt.com/canvas/shared/68341217ae788191b66a523c948b1a8e
 
superscv 2025-05-26

A segunda quickSortInPlace() anexada também é uma implementação lenta.

Execute o código abaixo.

function quickSortInPlace(arr, left = 0, right = arr.length - 1) {
if (left >= right) return;

const pivotIndex = partition(arr, left, right);
quickSortInPlace(arr, left, pivotIndex - 1);
quickSortInPlace(arr, pivotIndex + 1, right);
}

function partition(arr, left, right) {
const pivot = arr[right];
let i = left;

for (let j = left; j < right; j++) {
if (arr[j] < pivot) {
[arr[i], arr[j]] = [arr[j], arr[i]];
i++;
}
}

[arr[i], arr[right]] = [arr[right], arr[i]];
return i;
}

function quickSort(arr) {
if (arr.length <= 1) return arr;

const pivot = arr[arr.length - 1];
const left = [];
const right = [];

for (let i = 0; i < arr.length - 1; i++) {
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}

return [...quickSort(left), pivot, ...quickSort(right)];
}

const repeat = 100;
const arrLength = 10000;
const unsortedArray = new Array<number>();
for(let i = 0; i < arrLength; i++)
unsortedArray.push(Math.round(Math.random() * arrLength));

let sorted: Array<number>;

const qb = performance.now();
for(let i = 0; i < repeat; i++)
sorted = quickSort(unsortedArray);
const qe = performance.now();

const rqb = performance.now();
for(let i = 0; i < repeat; i++) {
let copied = [...unsortedArray];
quickSortInPlace(copied);
}
const rqe = performance.now();

console.log(q: ${qe - qb} ::: rq: ${rqe - rqb});
 
superscv 2025-05-26

Basicamente, dá para ver que é um código que não tem nenhuma consideração pelo custo de criar, operar e mesclar coleções. No caso de C++, já havia propostas/implementações de MoveConstructor cerca de 10 anos atrás, e estar sempre muito atento ao custo relacionado à cópia de memória é o mais básico do básico. O quick sort, por seu mecanismo, é um algoritmo capaz de determinar o índice de todos os valores, e é melhor que cada campo ofereça acesso aleatório.

Mesmo sem otimizações maníacas, só aplicando o que foi dito acima já dá uma diferença de desempenho de mais de 2x em relação ao método do link que você passou.
 
dudlf016 2025-05-27

Eu executei diretamente, e há uma tendência de ser um pouco mais lento, mas não parece chegar a 2x.

function quickSortInPlace(arr, left = 0, right = arr.length - 1) {  
    if (left &gt;= right) return;  
  
    const pivotIndex = partition(arr, left, right);  
    quickSortInPlace(arr, left, pivotIndex - 1);  
    quickSortInPlace(arr, pivotIndex + 1, right);  
}  
  
function partition(arr, left, right) {  
    const pivot = arr[right];  
    let i = left;  
  
    for (let j = left; j &lt; right; j++) {  
        if (arr[j] &lt; pivot) {  
            [arr[i], arr[j]] = [arr[j], arr[i]];  
            i++;  
        }  
    }  
  
    [arr[i], arr[right]] = [arr[right], arr[i]];  
    return i;  
}  
  
function quickSort(arr) {  
    if (arr.length &lt;= 1) return arr;  
  
    const pivot = arr[arr.length - 1];  
    const left = [];  
    const right = [];  
  
    for (let i = 0; i &lt; arr.length - 1; i++) {  
        if (arr[i] &lt; pivot) {  
            left.push(arr[i]);  
        } else {  
            right.push(arr[i]);  
        }  
    }  
  
    return [...quickSort(left), pivot, ...quickSort(right)];  
}  
  
// =============  
  
function quickSortGPT(arr) {  
    if (!Array.isArray(arr)) {  
        throw new TypeError('quickSort expects an array');  
    }  
    if (arr.length &lt;= 1) return [...arr];  
  
    const pivot = arr[Math.floor(arr.length / 2)];  
    const left = [];  
    const equal = [];  
    const right = [];  
  
    for (const el of arr) {  
        if (el &lt; pivot) left.push(el);  
        else if (el &gt; pivot) right.push(el);  
        else equal.push(el);  
    }  
  
    return [...quickSortGPT(left), ...equal, ...quickSortGPT(right)];  
}  
  
function quickSortInPlaceGPT(arr) {  
    if (!Array.isArray(arr)) {  
        throw new TypeError('quickSortInPlace expects an array');  
    }  
  
    const stack = [[0, arr.length - 1]];  
  
    while (stack.length) {  
        const [lo, hi] = stack.pop();  
        if (lo &gt;= hi) continue;  
  
        const pivotIndex = partitionGPT(arr, lo, hi);  
  
        // Eliminação de recursão de cauda: empurra primeiro a partição maior  
        if (pivotIndex - 1 - lo &gt; hi - (pivotIndex + 1)) {  
            stack.push([lo, pivotIndex - 1]);  
            stack.push([pivotIndex + 1, hi]);  
        } else {  
            stack.push([pivotIndex + 1, hi]);  
            stack.push([lo, pivotIndex - 1]);  
        }  
    }  
    return arr;  
}  
  
function medianOfThreeGPT(a, b, c) {  
    return (a - b) * (c - a) &gt;= 0 ? a  
        : (b - a) * (c - b) &gt;= 0 ? b  
            : c;  
}  
  
function partitionGPT(arr, lo, hi) {  
    const mid = lo + ((hi - lo) &gt;&gt; 1);  
    const pivotValue = medianOfThreeGPT(arr[lo], arr[mid], arr[hi]);  
  
    while (true) {  
        while (arr[lo] &lt; pivotValue) lo++;  
        while (arr[hi] &gt; pivotValue) hi--;  
  
        if (lo &gt;= hi) return hi;  
  
        [arr[lo], arr[hi]] = [arr[hi], arr[lo]];  
        lo++;  
        hi--;  
    }  
}  
  
function testQuicksort(qs, qsp) {  
    const repeat = 100;  
    const arrLength = 100000;  
    const unsortedArray = new Array();  
    for (let i = 0; i &lt; arrLength; i++)  
        unsortedArray.push(Math.round(Math.random() * arrLength));  
  
    let sorted = [];  
  
    const qb = performance.now();  
    for (let i = 0; i &lt; repeat; i++)  
        sorted = qs(unsortedArray);  
    const qe = performance.now();  
  
    const rqb = performance.now();  
    for (let i = 0; i &lt; repeat; i++) {  
        let copied = [...unsortedArray];  
        qsp(copied);  
    }  
    const rqe = performance.now();  
  
    // até 2 casas decimais  
    const p1 = ((qe - qb) / repeat).toFixed(2);  
    const p2 = ((rqe - rqb) / repeat).toFixed(2);  
    
    console.log(`Quicksort: ${p1} ms, In-place: ${p2} ms`);  
}  
  
function main() {  
    const useGPT = process.argv.includes('--gpt');  
    console.log(`Using ${useGPT ? 'GPT' : 'geekNews'} quicksort implementation.`);  
    if (useGPT) {  
        testQuicksort(quickSortGPT, quickSortInPlaceGPT);  
    } else {  
        testQuicksort(quickSort, quickSortInPlace);  
    }  
}  
  
main();

===
node q.js
Using geekNews quicksort implementation.
Quicksort: 29.55 ms, In-place: 9.94 ms
node q.js
Using geekNews quicksort implementation.
Quicksort: 28.42 ms, In-place: 9.07 ms
node q.js
Using geekNews quicksort implementation.
Quicksort: 26.91 ms, In-place: 9.15 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 28.73 ms, In-place: 9.22 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 26.87 ms, In-place: 9.22 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 27.97 ms, In-place: 9.30 ms
node --version
v22.14.0

bun q.js
Using geekNews quicksort implementation.
Quicksort: 32.05 ms, In-place: 17.39 ms
bun q.js
Using geekNews quicksort implementation.
Quicksort: 30.97 ms, In-place: 17.82 ms
bun q.js
Using geekNews quicksort implementation.
Quicksort: 29.73 ms, In-place: 16.14 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 30.61 ms, In-place: 12.63 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 31.09 ms, In-place: 12.76 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 33.24 ms, In-place: 12.75 ms
bun --version
1.2.14

deno q.js
Using geekNews quicksort implementation.
Quicksort: 32.30 ms, In-place: 6.79 ms
deno q.js
Using geekNews quicksort implementation.
Quicksort: 26.79 ms, In-place: 6.86 ms
deno q.js
Using geekNews quicksort implementation.
Quicksort: 26.09 ms, In-place: 6.85 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 27.18 ms, In-place: 7.92 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 25.34 ms, In-place: 8.12 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 25.39 ms, In-place: 8.09 ms
deno --version
deno 2.3.3 (stable, release, x86_64-pc-windows-msvc)
v8 13.7.152.6-rusty
typescript 5.8.3
 
superscv 2025-05-27

Ah.. entendi o que você quis dizer. Pelo visto, você não tinha entendido o que deveria ser comparado.... o algoritmo quick sort não tem dois modos de implementação, quicksort e in-place......

Desde o início, o ponto criticado foi o fato de terem escrito quickSortGPT() e quickSort() no código acima — ambos códigos gerados pelo GPT — com mesclagem de Array embutida, e de terem fornecido isso aos usuários de IA.
 
dudlf016 2025-05-27

Na resposta do GPT havia tanto quickSort quanto quicSortInPlace, e como você apontou nos comentários a parte [...,quickSort(left), ...equal, ...quickSort(right)], eu entendi que a comparação deveria ser feita entre quickSort com quickSort e quickSortInPlace com quickSortInPlace, mas pelo visto não é isso.
 
superscv 2025-05-27

A frase "quickSort com quickSort" me faz levar a mão à nuca.
 
superscv 2025-05-27

Ao ler o texto, por favor confira o contexto.

Não estou me gabando da minha habilidade de programação. O que estou apontando é que códigos ruins como o quickSort(), usado agora como exemplo, estão sendo exibidos com alta prioridade pelo GPT.

Se você fizer várias buscas no GPT, verá que em muitos casos ele fornece isoladamente o resultado da função quickSort() e, de novo, quickSort() é apenas um exemplo. Quando se pede código ao GPT para uso em trabalho, ele frequentemente gera códigos de qualidade muito baixa (falo pela experiência de um usuário pago). Se o próprio desenvolvedor não tiver a capacidade de distinguir isso, concordo com a opinião do autor do texto de que há uma grande chance de o projeto seguir por um caminho que o destrua, e foi assim que cheguei ao contexto atual.

Ao meu redor, já está aumentando continuamente o número de projetos recheados com esse tipo de código péssimo.
 
superscv 2025-05-27

Obviamente, a comparação deve ser feita entre o desempenho das duas funções quickSort() e quickSortInPlace()........
 
superscv 2025-05-27

Compartilham um resultado mostrando uma diferença que passa de 2x e chega a 3~4x, e depois dizem que talvez não seja nem 2x?
 
superscv 2025-05-26

return [...quickSort(left), ...equal, ...quickSort(right)];

Pense bem sobre este trecho do código.
 
roxie 2025-05-27

Aprendo muito.
 
ohnul 2025-05-26

Obrigado pela resposta!
 
crawler 2025-05-26

Primeiro, no que eu disse sobre "usar IA dentro do domínio", é claro que o design e a coordenação ficam a cargo dos humanos...
Na verdade, isso talvez fosse algo a se dizer antigamente, mas hoje, quando todo mundo já conhece as limitações dos LLMs, virou algo tão óbvio que nem precisa ser mencionado.

Em seguida, sobre o caso de pessoas comuns sem conhecimento de desenvolvimento usarem LLMs,
acho que nem o texto principal, nem o Hacker News, nem eu chegamos a falar disso, mas, de qualquer forma, mesmo nesse caso a tecnologia já chegou a um nível em que os usuários ficam satisfeitos com o resultado.
Se não fosse assim, Bolt.new, v0 e até o Cursor não estariam recebendo a avaliação que têm hoje.
 
superscv 2025-05-26

Resumo,

Autor: os próprios desenvolvedores precisam desenvolver e preservar suas capacidades. Além disso, a IA nem funciona tão bem assim.

crawler: Hã? Para mim funciona bem?

superscv: Tem muitos problemas...

crawler: Tem que saber ajustar e usar

superscv: Acho que já se afastou demais da mensagem que o autor queria transmitir desde o começo..
 
crawler 2025-05-26

Acho que você não entendeu bem por que eu mencionei a área de atuação do autor e o que significa ter o próprio domínio de conhecimento.
Delegar todas as decisões à IA sem pensar por conta própria também me parece tolice,
mas também não entendo muito bem as pessoas que estão no extremo oposto.

Por fim, o que eu queria perguntar é: superscv, como você acha que seria bom usar LLMs na programação?
 
superscv 2025-05-26

Normalmente não costumo deixar comentários, mas o motivo de eu ter comentado neste texto em particular é porque concordo bastante com a visão do autor. O importante não é a IA ou os LLMs, e sim que, independentemente do ambiente que vier, eu, como desenvolvedor, esteja preparado.

Como os LLMs, pelas características do código-fonte com que foram treinados, acabam oferecendo principalmente dados próximos da média dos dados online espalhados pelo mundo, (o quicksort em js citado antes prova isso), eu geralmente os uso para perguntar se algo, do ponto de vista de ideias/design, está razoavelmente alinhado com uma perspectiva comum ou destoando dela, ou então para tirar dúvidas sobre temas para os quais era meio difícil encontrar a quem perguntar até então.
 
superscv 2025-05-26

Além disso, não vejo muito sentido em continuar a conversa.

Se a opinião desde o início era que o código gerado pela IA pode ter alguns fatores de risco e, por isso, seria bom refiná-lo bem e usá-lo de forma adequada, então talvez bastasse explicar em que ponto o texto do autor distorce ou enviesa esse pensamento. Até no resumo há um trecho com sentido parecido: "ela pode fornecer rapidamente código scaffold/rascunho sem contexto, mas o design completo e o ajuste fino continuam sendo responsabilidade dos desenvolvedores humanos".
 
superscv 2025-05-26

Embora a mensagem do autor tenda a ser um tanto forte, se você ler o texto com atenção, não é “não use IA”. Há uma proposta sobre como utilizá-la, e o ponto principal é a mensagem de que o próprio desenvolvedor não pode carecer de competência.

Se formos ver por que a mensagem do autor soa tão forte, ela foi construída como uma resposta à visão de que será possível desenvolver com o Copilot (com a nuance de uma alta dependência de desenvolvimento em relação ao Copilot). Nesse contexto, ele conduziu a mensagem no sentido de não adotar uma postura que prejudique, para os próprios desenvolvedores, o valor da sua existência.

Como o autor também não está passando a mensagem de “não use IA”, no fim, se a ideia é aproveitar a IA, isso acabará ficando em algum ponto de equilíbrio; por isso, a mensagem ficou, em linhas gerais, parecida com o que você respondeu há pouco.

No entanto, tive dificuldade em concordar com a parte de “visão tendenciosa” no que você escreveu inicialmente, então quis responder primeiro sobre isso.
 
GN⁺ 2025-05-25
Comentários do Hacker News

  • Se você quer criar um software que precise ser absolutamente robusto, como o de um marcapasso, de um sistema de guiagem de mísseis ou de um tanque M1, então é melhor deixar os agentes de codificação com IA de lado e adotar uma postura de aprender por conta própria
    Mas a maioria de nós não está construindo esse tipo de coisa; estamos criando apps CRUD com requisitos quase idênticos, mudando só um pouco o schema e a forma de integração
    Na prática, quase nada do software que a maioria de nós faz é realmente novo
    Muitas vezes, o melhor caminho é reutilizar conhecimento já existente
    Para mim, agentes de código são uma versão turbinada da velha reutilização de código
    E, de quebra, ironicamente, esse próprio texto pareceu um texto escrito por IA

    • Eu nem quero escrever código low-level mission-critical para começo de conversa
      Não acho que as ferramentas de IA sejam tão úteis quanto o autor acha, mas já encheu esse papo de que “se você não faz programação de sistemas em C, então nem é programador”
      Eu gosto de fazer frontend
      Também não tenho vontade de criar biblioteca gráfica de baixo nível do zero
      Não sou o tipo que acorda de madrugada tomado por uma epifania para sair hackeando, mas tenho paixão e orgulho pelo meu trabalho
      Não acho que todo mundo precise adotar essa postura extrema do autor
      Acho que precisa haver diversidade no mercado de software

    • Tudo bem rebater o argumento do autor, mas dizer que esse texto em si foi escrito por IA já é demais
      O autor colocou no texto todo um estilo próprio, com imagens vívidas, metáforas fortes e um humor genuinamente engraçado
      No estado atual das coisas, é realmente muito difícil um LLM escrever algo assim
      Isso não é IA; é simplesmente um texto bem escrito
      Concorde ou não com a tese, a qualidade da escrita merece reconhecimento

    • O texto original também traz uma passagem assim
      “Provavelmente você não vai escrever o código que mantém aviões no ar, nem o código diretamente ligado à vida humana. A maioria não vai. Mas mesmo que você trabalhe numa empresa empilhando app CRUD simples sobre app CRUD simples, ainda assim tem a responsabilidade de tratar o usuário com respeito e dignidade”
      Isso reforça que mesmo software simples exige ao menos um senso mínimo de responsabilidade

    • Na prática, o próprio autor reconhece alguns casos em que IA é útil
      O ponto central do autor é que chamamos a IA de “copiloto”, e isso pode levar iniciantes a confiar demais nela
      Um copiloto de verdade deveria ser um profissional experiente e um colega de trabalho, mas a IA ainda é, com frequência, meio colega ruim
      “Hoje estamos deixando a curiosidade e a iniciativa do lado de fora do sistema. Gente com potencial real de crescimento vai perdendo o entusiasmo enquanto revisa patchsets feitos por IA. O terminal vira planilha, o debugger vira caixão”
      Ainda assim, IA é só mais uma abstração
      Assim como houve quem se preocupasse que automações como GC (garbage collector) fariam as pessoas perderem fundamentos, também existe o receio de que a IA acabe corroendo habilidades muito básicas de programação e aprendizado
      Desenvolvedores web conseguem criar bons sites na maior parte do tempo sem conhecer a fundo toda a estrutura da stack, graças às abstrações
      Mas a abstração da IA tem muitos buracos, e ainda assim dá para fazer certas coisas funcionarem sem realmente dominar os fundamentos
      O problema é que, em algum momento, você descobre que bugs sérios estão escondidos ali, e depuração, resolução de problemas e capacidade de aprender por conta própria são coisas que a IA não pode substituir
      Por isso existe o medo de que, se aprender ficar fácil demais com IA, competências fundamentais acabem sendo puladas
      No fim, crescimento real vem de repetição e de bater de frente com o problema você mesmo
      Se a IA abstrair até o próprio “aprender”, no longo prazo isso enfraquece a capacidade dos desenvolvedores
      Claro, não é que todo mundo que usar IA vai ficar burro, e pessoas proativas ainda vão continuar existindo
      Mas, no geral, é bem possível que a proporção delas diminua
      Porque a própria experiência de “construir pensando por si mesmo”, tão importante para iniciantes, pode desaparecer
      E essa abstração chamada IA, no fim das contas, está cheia de lacunas
      Para quem está começando, parece que a IA faz tudo, mas no fim você ainda precisa de competência essencial de programação e debugging
      Então, se você quer realmente identificar os problemas do código gerado por IA, precisa sim construir conhecimento técnico
      Eu também uso muito bem assistentes de código com IA
      Mas eles têm desvantagens, então minha conclusão é que não dá para olhar para isso como se fosse só coisa boa

    • Fiz uns vídeos curtos de comédia do meu jeito com o Google Whisk e subi no TikTok, e quando entrei lá era só conteúdo gerado por IA e vídeos de gente copiando uns aos outros
      Eu achava que existia algo realmente especial em “criação original”, mas no fim somos seres fáceis demais de reproduzir
      Mesmo que a gente suba vídeos programando todo dia no TikTok, vai ser sempre a repetição infinita dos mesmos apps
      Como diria Elon Musk, parece que agora só resta ir para Marte de verdade
      Já falei dois anos atrás que os LLMs não “alucinavam” tanto assim, e até hoje as pessoas seguem acreditando que humanos continuam indispensáveis, mas eu quero dizer que isso está ficando cada vez menos verdade
      Quero relembrar essa conversa daqui a 2 anos

  • “A máquina é real. O silício, a DRAM, o cache L1, o false sharing, o branch predictor jogando uma moeda para decidir — tudo isso é real. Se você se importa, pode lidar com isso”
    Fazia muito tempo que eu não achava uma frase tão bonita

    • Senti exatamente a mesma coisa
      O autor escreveu num estilo divertido, meio Dave Barry, e eu ri alto várias vezes
      Gostei de como ele expressou, com humor, pensamentos sobre o Copilot com os quais dá para se identificar

  • Uma coisa que costuma faltar em discussões sobre desenvolvimento de software é que não existe só o “resultado final do código escrito”
    A própria jornada até chegar ao resultado, passando por inúmeros trade-offs, é importantíssima
    Basta tentar desenvolver uma única funcionalidade com um júnior em uma base de código um pouco complexa para perceber na hora quais trade-offs um engenheiro experiente faz quase sem pensar
    A IA até tem alguma noção desses trade-offs, mas na maior parte aprende isso por observação
    Ela de fato ajuda a “escrever código melhor”, mas julgar e pensar continuam sendo tarefas humanas
    LLM não “pensa”
    E, quanto mais a IA evoluir, maior pode ser o risco de as pessoas pensarem menos

  • Para mim, os prós e contras do Copilot fazem todo sentido
    Mas, diferente dessa imagem do hacker ou do “artesanato” da infância, engenheiros sempre foram engenheiros
    Se hoje temos tecnologias centrais, é porque na época as pessoas precisavam resolver aqueles obstáculos de qualquer jeito
    Generalizar essa história dramática como se fosse “o jeito normal de trabalhar antigamente” traz um risco de viés

    • Sou engenheiro de software há mais de 20 anos, desenvolvendo pelo caminho mais difícil, e resolver problemas realmente complicados sempre foi um privilégio e uma fonte de satisfação
      Atualizações simples de CRUD são repetitivas e entediantes, mas aquelas tarefas ocasionais que fazem a cabeça doer, os momentos em que uso algo que aprendi na faculdade, ou casos especiais como algoritmos recursivos, são joias da carreira
      Espero que futuros engenheiros de software guiados por IA valorizem ainda mais esse tipo de experiência
      A IA pode até apresentar respostas com aparência lógica, mas às vezes erra de forma totalmente descabida e perigosa, então sempre vai ser preciso alguém que realmente saiba o que precisa ser feito
      Quando AIs “alucinam” ou falta contexto, sempre haverá situações em que no fim um humano terá de resolver o problema

  • Meu parâmetro de comparação não é pair programming, e sim desenvolvedores terceirizados no exterior
    Na real, Copilot, Cursor e outras ferramentas de IA parecem muito melhores porque eu não preciso mais desperdiçar tempo em chamadas no Zoom por causa de comunicação ambígua, barreiras de idioma e diferenças de entendimento
    Por exemplo, aquelas situações comuns em terceirização em que “foi adicionada uma função isChild relacionada ao nó raiz, que retorna boolean, mas ela não tem nada a ver com verificar existência de pai”, ou “de repente a API não aceita mais array como parâmetro”
    Quando trabalho com IA, mesmo que esse tipo de problema aconteça, basta dizer que está errado e explicar o motivo que ela corrige rápido
    Quase não existe o mesmo nível de desgaste com comunicação, mal-entendidos ou perda de tempo que existe com pessoas
    No momento em que IA se conectar facilmente a tickets do Jira, uns 80% do trabalho de desenvolvimento vai virar redação de ticket e supervisão
    Claro que isso não significa o fim do papel do engenheiro — a área de negócios não vai escrever bons tickets, e no fim alguém sempre precisa assumir a responsabilidade final
    Mesmo assim, muitas organizações vão esquecer esse fato, e daí existe espaço para grandes desastres

  • O trecho que mais ficou para mim neste texto foi
    “Vamos passar a glorificar como ápice a realidade retrógrada, inchada e excessivamente abstraída do software atual. A cultura de espremer desempenho até o limite, ou de construir sistemas secos, afiados e claros, vai virar apenas história do passado”
    Existe o receio de que bibliotecas e padrões de arquitetura criados antes de 2023 virem a espinha dorsal dos dados de treinamento dos LLMs e acabem se cristalizando
    Em vez de continuar inovando, talvez a gente só perpetue para sempre dependências acumuladas e código bagunçado dos últimos 30 anos
    Até coisas como Javascript parecem condenadas a viver para sempre, o que me preocupa

  • Tenho sentido na pele a pressão constante da liderança dizendo “não estamos usando IA o suficiente” e “se adotarmos IA, dá para cortar os cronogramas pela metade”
    Somos pressionados a adotar novas ferramentas de IA para bater KPI, e se não conseguirmos nos adaptar, já se fala até em reduzir equipe
    Parece que o mundo enlouqueceu de vez
    A IA sempre é vendida como “uma ferramenta para substituir o trabalho dos outros”
    Na prática, isso só parece verdade quando estou avaliando o trabalho de outra pessoa sem realmente entender bem o que ela faz
    Parece que a gestão pegou esse martelo chamado IA e está tentando transformar tudo em prego

    • Precisamos mesmo encontrar um jeito de reduzir de alguma forma essa estrutura gerencial e voltar a dedicar tempo a trabalho realmente produtivo
      Espero uma cultura mais focada em execução e entrega real do que em uso de IA

    • Isso na verdade é só o padrão clássico do hype cycle da indústria de IA
      Quando a poeira baixar, só vão restar ferramentas e tecnologias que realmente prestam, e a maioria vai desaparecer
      O caminho para sobreviver é entender com inteligência o que de fato vai ficar e, se possível, influenciar essa mudança

    • Essa imposição atual de “adote logo” é o oposto completo da essência da engenharia, do design e do trabalho técnico como eu conhecia
      O normal sempre foi avaliar com cuidado se valia a pena adotar uma ferramenta, linguagem ou serviço, justificar por que fazia sentido para o nosso caso e levantar com clareza as vantagens e desvantagens
      O processo correto sempre foi decidir com base em “por que isso é necessário?” e “por que este serviço é mais razoável?”
      Havia um processo para testar se a tecnologia realmente precisava ser adotada e depois avaliar os resultados e a eficiência dessa adoção
      As empresas de hoje estão se afastando desse jeito saudável de trabalhar

    • Essa fantasia de que “IA é sempre uma ferramenta capaz de substituir o trabalho dos outros” está forte demais
      De fato existe muito trabalho repetitivo, mas a maioria das atividades, para ser bem feita, exige nuances e delicadezas próprias, e há um grande risco de tudo isso se perder na automação
      Não concordo com esse papo de que “se a IA fizer 80%, já está bom”
      Erros afetam o sistema como um todo, e quem avalia quase sempre não tem vivência suficiente do trabalho real

    • Acho que em breve os cargos de gestão vão desaparecer mais rápido ainda
      Até lá, força para todos nós

  • O autor claramente parece ser desenvolvedor C++
    Na prática, assistentes de programação com IA raramente funcionam direito em C++, e quem costuma usá-los bem em geral trabalha com linguagens de script ou apps CRUD

    • Pelos posts antigos do autor, ele parece ser desenvolvedor de jogos
      Como conhecimento e material de desenvolvimento de jogos não foram absorvidos em massa por LLMs, diferente do caso de apps CRUD, imagino que o autor perceba mais claramente os limites dos LLMs

  • Partes desse texto parecem ser lidas com a voz do personagem Bertram Gilfoyle, de Silicon Valley
    Queria saber se fui o único a sentir isso

  • O ponto central é manter sempre a capacidade de “telescópio”
    Tudo bem trabalhar em níveis mais altos graças a agentes de código, mas, quando necessário, você precisa continuar capaz de mergulhar fundo no código, entender por conta própria e corrigir diretamente para estar seguro