Degenerative Code Review: Quando a IA Esquece da Performance

Recentemente fui convidado para uma missão muito especial: ser mentor de um amigo que sonha conquistar uma vaga de trabalho em empresas fora do Brasil. Sabemos que esse tipo de vaga exige domínio de algoritmos e estruturas de dados — com plataformas como LeetCode e HackerRank sendo o campo de batalha.

Começamos do básico. O primeiro algoritmo que estudamos juntos foi o clássico Two Pointer.

🚀 Versão 1: A boa e velha busca linear

Primeiro, implementamos uma solução simples para encontrar o maior número de um array:

function linearSearch(n: number[]): number {
  let biggerNumber: number = n[0]
  for (let i in n) {
    if (n[i] > biggerNumber) {
      biggerNumber = n[i]
    }
  }

  return biggerNumber
}

🔁 Versão 2: A técnica Two Pointer

Depois, partimos para uma abordagem mais performática — usando dois ponteiros:

function twoPointerSearch(n: number[]): number {
  let left = 0
  let right = n.length - 1
  let biggerNumber: number = n[0]

  while (left <= right) {
    if (n[left] > biggerNumber) {
      biggerNumber = n[left]
    }

    if (n[right] > biggerNumber) {
      biggerNumber = n[right]
    }

    left++
    right--
  }

  return biggerNumber
}

📈 Benchmarking

Para testar a performance:

console.log('Linear search')
console.time("linear")
console.log(linearSearch(numbers))
console.timeEnd("linear")

console.log('Two pointer search')
console.time("twoPointerSearch")
console.log(twoPointerSearch(numbers))
console.timeEnd("twoPointerSearch")

Linear search:         0.066ms
Two pointer search:    0.037ms

Ambas as abordagens retornaram corretamente o maior número (1000), mas a técnica Two Pointer foi quase duas vezes mais rápida.

🤖 A IA entra em cena

Curiosos, pedimos para a IA revisar nosso código com um prompt simples:

“Temos esse algoritmo Two Pointer. Poderia fazer um code review?”

A IA deu feedbacks úteis — como a melhoria no posicionamento dos incrementos — , mas o que chamou atenção foi uma refatoração usando Math.max para deixar o código mais legível:

function twoPointerSearch2(n: number[]): number {
  let left = 0
  let right = n.length - 1
  let biggerNumber: number = n[0]

  while (left <= right) {
    biggerNumber = Math.max(biggerNumber, n[left], n[right])
    left++
    right--
  }

  return biggerNumber
}

Ao ver essa versão, pensei: “Uau, que código elegante!”

Get Rogerio Santos’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Mas aí vem a surpresa…

console.log('Two pointer search with Math.max')
console.time("twoPointerSearch2")
console.log(twoPointerSearch2(numbers))
console.timeEnd("twoPointerSearch2")

Two pointer search with Math.max: 0.099ms

Mais lento que as versões anteriores! 😬

📌 Conclusões que ficam

• A IA trouxe um código mais elegante, mas menos performático.
• Métricas não mentem.
• A elegância nem sempre significa eficiência.
• O código da IA não veio com um disclaimer de performance — e isso é perigoso.
• Não podemos confiar cegamente na IA.
• Mesmo em um exemplo simples como esse, ela pode nos induzir a caminhos menos eficientes. O papel do desenvolvedor continua sendo essencial: questionar, medir, testar, entender.

Use IA, mas nunca desligue seu modo crítico. IA é copiloto, você é o piloto. ✈️