Porque copiar código da AI está a matar a sua carreira

Já deve ter ouvido aquela frase batida: «Se não está a usar inteligência artificial hoje, está a ficar para trás». Pois, seria uma frase que eu adoraria usar... se acreditasse nela. Mas não acredito. Na verdade, tenho observado algo bastante diferente: a maioria das pessoas está a utilizar a AI de uma forma que, para além de não ajudar, está a prejudicar ativamente o seu desenvolvimento profissional.

O curioso caso do developer que não programa

Vamos dar uma volta mais profunda a este assunto, especialmente focando-nos na utilização do ChatGPT e ferramentas similares no desenvolvimento de software. E vou dizer-lhe porque é que esta abordagem atual pode estar a prejudicá-lo mais do que a ajudá-lo.

Primeiro, vamos falar de algo curioso no mundo do desenvolvimento. Quando se pergunta a um developer qual a parte do trabalho que mais gosta, a resposta é normalmente «programar, escrever código». E quando pergunta do que menos gosta? «Ah, reuniões e fazer code review». Tem piada, não tem? A única parte do trabalho que dizem adorar é precisamente a que estão a externalizar para a AI. Há algo estranho aí, não?

O mito do amor pelo código: O caso LeftPad

Na verdade, tenho as minhas dúvidas se os developers realmente adoram assim tanto escrever código. Deixa-me mostrar-te algo interessante: conheces o famoso caso do leftpad? Vejam estas 11 linhas de código que quebraram literalmente milhões de aplicações JavaScript:

module.exports = leftpad;
function leftpad (str, len, ch) {
    str = String(str);
    var i = -1;
    if (!ch && ch !== 0) ch = ' ';
    len = len - str.length;
    while (++i < len) {
        str = ch + str;
    }
    return str;
}

Sim, apenas isso! Uma função simples que adiciona caracteres à esquerda de uma string até atingir um determinado comprimento. E porque é que isso partiu tanta coisa? Porque os developers «adoravam» tanto escrever código que, em vez de implementarem esta simples função, preferiram importar uma biblioteca externa. E quando essa biblioteca foi retirada do npm... bem, foi o caos.

E não se fica por aí. No mundo JavaScript, temos também a biblioteca «is-odd» - sim, uma biblioteca inteira só para verificar se um número é ímpar, o que implica que os developers não sabem trabalhar com módulo! Se isto não é prova suficiente de que estes tipos não são assim tão apaixonados por escrever código, não sei o que seria!

Mas eis o ponto crucial que muita gente não entende: o nosso trabalho não é ser «dactilógrafo de código». Não somos escritores de código, somos programadores de software. E desenvolver software vai muito além de simplesmente gerar linhas de código. Se fosse só isso, bastava abrir o GitHub e começar a copiar e colar - afinal, já há código suficiente no mundo, não?

ChatGPT e o Quick Sort: Uma história de dois códigos

Vamos falar sobre a forma errada de usar o ChatGPT, que infelizmente se tornou muito comum. É aquela história: a pessoa vai lá, pede «por favor, faz-me uma função de quick sort em Python» (sim, eu digo sempre por favor à AI, vai que eles dominam o mundo um dia), e recebe algo do género:

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) //2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

À primeira vista, parece um código bonito, não é? Mas há aqui um problema grave. Esta implementação, embora funcione, é terrivelmente ineficiente em termos de memória. A cada chamada recursiva, são criados três novos arrays (left, middle e right). Num array grande, isto significa uma quantidade significativa de memória a ser alocada desnecessariamente.

Quando apontei este problema ao ChatGPT, este forneceu-me uma versão melhorada:

def quicksort(arr, low, high):
    if low < high:
        pivot_index = partition(arr, low, high)
        quicksort(arr, low, pivot_index - 1)
        quicksort(arr, pivot_index + 1, high)

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] < pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return i + 1

Esta versão é muito mais eficiente porque faz a ordenação «in-place», ou seja, modifica o array original em vez de criar novos arrays a cada passo. Mas aqui está o problema: se você não compreende o algoritmo quick sort, como saberia que a primeira implementação era má? Como saberia sugerir melhorias? Como compreenderia as implicações de performance no seu sistema?

Os quatro Cavaleiros do Apocalipse do código gerado

E isto leva-nos aos quatro grandes problemas desta abordagem de «copiar e colar» código da AI:

• Em primeiro lugar, está potencialmente a introduzir código de baixa qualidade na sua base de código. Se não percebe o que está a copiar, como vai saber se é bom ou mau?

• Em segundo lugar, o código gerado pela AI raramente se adequa perfeitamente aos padrões e convenções do seu projeto. Cada base de código tem as suas particularidades, os seus design patterns, as suas regras. O ChatGPT não conhece o seu projecto, não conhece estas convenções.

• Terceiro, código que não compreende é código difícil de manter. Pode parecer que está a poupar tempo agora, mas espere até precisar de fazer modificações ou corrigir bugs neste código mais tarde. Já viu aqueles ficheiros PHP com 100 mil linhas? Pois, normalmente começam assim.

• E o quarto problema, que considero o mais grave: não está a aprender. Está a criar uma dependência da AI sem desenvolver as suas próprias capacidades. E isso vai prejudicá-lo muito quando enfrentar problemas mais complexos, aqueles que a AI não consegue resolver sozinho.

A armadilha da velocidade: Rápido hoje, bloqueado amanhã

Imagine que está a tentar clonar uma aplicação complexa como o Uber Eats usando apenas o ChatGPT. A dada altura, vai esbarrar em problemas que a AI não consegue resolver. E aí? Se não desenvolveu um entendimento profundo do que está a fazer, vai ficar completamente preso.

É como usar uma muleta quando não se está realmente ferido - parece uma ajuda, mas na verdade está a impedi-lo de desenvolver força própria. Sim, utilizar o ChatGPT para gerar código pode parecer mais rápido a curto prazo. Consegues aquela implementação do quick sort em segundos, em vez de passares algum tempo a estudar e a implementar por conta própria. Mas é uma vitória falsa - ganha a batalha do momento, mas está a perder a guerra do seu desenvolvimento profissional.

O verdadeiro custo da dependência da AI

O verdadeiro desenvolvimento de software não se trata de escrever código rapidamente - trata-se de compreender problemas, arquitetar soluções, manter sistemas escaláveis e criar código que outros developers possam compreender e manter. Trata-se de crescer enquanto profissional e ser capaz de enfrentar desafios cada vez mais complexos.

Usar a AI como muleta para gerar código está a impedi-lo de desenvolver estas competências fundamentais. Cada vez que copia e cola sem compreender, está a perder uma oportunidade de aprendizagem, de crescimento. Está a condenar-se a ser um eterno júnior, dependente de ferramentas externas para realizar o seu trabalho.

O código que não entende é como uma dívida técnica que vai precisar de pagar com juros no futuro. Cada pedaço de código copiado sem compreensão é um pequeno compromisso com a mediocridade, uma pequena renúncia ao seu potencial de crescimento.

A inteligência artificial é uma ferramenta incrível, mas como qualquer ferramenta, o seu valor depende da forma como a utilizamos. Em vez de a utilizarmos como muleta, devemos aprender a utilizá-la como apoio ao nosso desenvolvimento profissional, mantendo sempre o foco na compreensão profunda e no crescimento contínuo.

No final do dia, o que vai determinar o seu sucesso enquanto developer não é a sua capacidade de gerar código rapidamente, mas sim a sua capacidade de compreender, arquitetar e manter sistemas complexos. E isso, meu amigo, nenhuma AI pode fazer por si.