CLAUDE CODE vs CODEX: quem encontra mais erros no seu código?

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: CLAUDE CODE vs CODEX: quem ENCONTRA MAIS ERROS no seu CÓDIGO? · Canal: Sandeco · 10:14 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Claude Code, Engenharia de software com IA

Resumo

O vídeo demonstra como Claude Code e Codex podem chamar um ao outro pelo terminal para revisar código de forma adversarial. Primeiro, Claude Code escreve uma implementação do algoritmo de Edmonds e Codex aponta possíveis problemas; depois, Codex cria uma árvore B+ e Claude Code revisa o resultado. O apresentador mostra correções e testes feitos após as revisões, além de comentar que essa abordagem pode reduzir o gargalo da avaliação humana. Ele ressalta, porém, que a revisão por IA não substitui a leitura do código por uma pessoa.

Pontos-chave

Claude Code e Codex podem ser chamados um pelo outro pelo terminal para analisar código.
O vídeo testa uma revisão em que uma IA procura falhas no código produzido pela outra.
Claude Code implementa o algoritmo de Edmonds, e Codex sugere correções e melhorias.
Codex implementa uma árvore B+, que Claude Code revisa em busca de problemas e oportunidades de melhoria.
O apresentador relata testes com casos aleatórios e entradas inválidas após aplicar correções.
A revisão por IA pode agilizar a avaliação de grandes volumes de código, mas a revisão humana continua sendo ideal.
O apresentador afirma que não conseguiu realizar o mesmo fluxo com Antigravity.

Capítulos

Início	Capítulo	Resumo
00:00	Proposta de revisão cruzada por IA	O apresentador propõe testar se Claude Code e Codex conseguem encontrar erros um no código do outro.
02:13	Chamando Claude Code e Codex pelo terminal	O vídeo demonstra como obter os comandos para iniciar uma ferramenta a partir da outra e enviar uma tarefa.
03:17	Geração dos algoritmos	Claude Code recebe a tarefa de implementar o algoritmo de Edmonds, enquanto Codex cria uma árvore B+.
05:23	Revisões cruzadas e correções	As ferramentas analisam os códigos uma da outra, apontam problemas e sugestões, e o apresentador aplica melhorias.
07:59	Resultados dos testes e limites da revisão humana	O apresentador comenta os testes e as melhorias e explica como a revisão por IA pode acelerar a avaliação de código sem substituir a revisão humana.

Citações

Você confia em código escrito por uma IA sem revisá-lo por conta própria? — 00:00

Um vai conseguir encontrar o erro do outro? Ou os dois vão concordar com o mesmo código incorreto? — 00:31

Nesse tipo de revisão adversarial, você pode revisar muito código com dois harness conectados um ao outro. — 05:23

A quantidade de código está ficando quase impraticável para uma pessoa avaliar. — 09:06

A avaliação humana acaba se tornando um gargalo no processo. — 09:38

Conceitos e entidades

Claude Code (ferramenta): Ferramenta usada no vídeo para escrever código e revisar a implementação produzida pelo Codex.
Codex (ferramenta): Ferramenta usada no vídeo para gerar código e analisar a implementação criada pelo Claude Code.
OpenCode (ferramenta): Ferramenta mencionada pelo apresentador como compatível com o fluxo de chamada entre ferramentas.
Antigravity (ferramenta): Ferramenta que o apresentador diz não ter conseguido integrar ao fluxo demonstrado.
Edmonds algorithm (conceito): Algoritmo solicitado para encontrar o maior conjunto de pares compatíveis sem repetir participantes.
B+ tree (conceito): Estrutura de dados solicitada no vídeo para organizar registros e permitir buscas, inserções, exclusões e consultas por intervalo.
adversarial code review (conceito): Abordagem em que uma ferramenta de IA examina o código produzido por outra e procura falhas ou melhorias.
Google (empresa): Empresa mencionada pelo apresentador ao comentar a integração com Antigravity.
Sandeco (pessoa): Apresentador do vídeo e nome usado nas demonstrações de interação com as ferramentas.

Tradução completa (pt-BR)

00:00 Me diga uma coisa: você confia em código escrito por uma IA sem revisá-lo por conta própria? E se eu usar outra inteligência artificial para tentar encontrar erros que passaram despercebidos durante a programação? Hoje, o Claude Code vai escrever um código e o Codex vai revisá-lo, porque esse é o estilo que estou usando agora para criar meu código. Depois, vamos inverter os papéis. O Codex vai escrever um código e o Claude Code vai procurar as falhas. Um constrói e o outro questiona. Mas

00:31 será que um vai conseguir encontrar o erro do outro? Ou será que os dois vão concordar com o mesmo código incorreto? É isso que vamos testar hoje. Neste vídeo, também vou mostrar como fazer revisão de código usando inteligência artificial. Certo, estou com o Claude Code aberto aqui do lado esquerdo e o Codex aberto aqui do lado direito. Entendeu? Vou fazer a seguinte pergunta ao Claude Code. Olha só: que comando de terminal você usaria para chamar o Codex no modo de permissões livres? Então, se eu pressionar Enter aqui, ele vai retornar exatamente

01:06 qual comando de terminal eu poderia usar para chamar o Codex diretamente. Então, para executar o Codex, eu chamaria codex --yolo. E aqui está a tarefa, ou seja, o prompt. Vou pegar isso aqui, copiar, abrir um novo terminal do Windows em qualquer lugar, sem problema nenhum. Vou colar e, nesta nova tarefa, vou dizer o seguinte. Olha só: diga olá, Sandeco. E o que vai acontecer? Ele vai abrir imediatamente, certo, o terminal aqui. Viu o que aconteceu? Ele abriu o

01:40 terminal, certo, a comunicação com o modelo aqui, no modelo GPT-6 Astra, com o provedor OpenAI, certo, sem necessidade de aprovação e tudo mais. O raciocínio dele vai estar no nível alto, certo? E aqui embaixo vou dizer: olá, diga olá, Sandeco. Foi isso que o usuário pediu, neste caso, eu. E aqui está o Codex respondendo: olá, Sandeco. Certo. Agora vamos inverter. Vou fechar o terminal aqui. Na verdade, não vou fechar. Só vou executar cls aqui para limpar a tela. Vou deixar este terminal quieto bem aqui. E agora vou inverter: vou chamar o Codex neste momento e dizer o seguinte. Olha só: que comando de terminal

02:13 você usaria para chamar o Claude Code no modo de permissões livres? Então, se eu pressionar Enter aqui, ele vai processar essa informação e me trazer o comando que eu poderia usar para chamar o Claude. Certo? Naturalmente, ele vai buscar isso na documentação oficial. Mas você vai ver que os dois harnesses sabem se comunicar, certo? Então, olha só, do mesmo jeito, né? claude --dangerously-skip-permissions. Certo. E como

02:44 eu passaria o prompt nesse comando? Isso aqui, isso que estou mostrando, é muito útil, porque vou mostrar que em breve podemos fazer os dois projetos conversarem entre si. Então, se eu copiar isso aqui agora, vou voltar ao terminal que estávamos usando antes para executar este comando aqui, só que vou dizer o mesmo que perguntei, certo? Diga olá, Sandeco. Certo, vamos lá. Agora, ao abrir o Claude, ele

03:17 vai ser chamado aqui para executar e vai dizer: “Olá, Sandeco, olá, Sandeco”. E então está tudo certo, funcionou, ficou ótimo, né? Agora, o que acontece é o seguinte. Bem, estou aqui no VS Code com o Claude Code e também com o Codex abertos em um projeto, certo? E vou pedir ao Claude Code para escrever um algoritmo. Vai ser o algoritmo de Edmonds, certo? Vamos fazer o seguinte. Olha só: vou pedir exatamente isto aqui. Escreva, certo? Vou colocar aqui em cima. Escreva um programa em Python

03:48 para o algoritmo de Edmonds, que encontre o maior número possível de pares em uma rede de conexões, sem usar o mesmo participante em dois pares. Por exemplo, ele permite formar o número máximo de pares entre pessoas compatíveis, reorganizando combinações anteriores quando isso possibilita incluir mais participantes. Esse algoritmo, pessoal, é bem chato de implementar, um pouco complicado. Vou dizer a ele aqui. Além disso, olha só, dê ao arquivo o nome claude.py. Escrevi errado aqui; vamos

04:21 colocar claude, certo? Vamos lá. Vou pedir ao Claude para fazer isso. Agora vou pedir ao Codex para escrever o seguinte. Olha só: escreva um programa em Python para uma árvore B+, organizando as informações em uma estrutura ramificada que permita buscar, inserir e excluir registros com eficiência, facilitando consultas por intervalo. Dê ao arquivo o nome codex.py. Vou enviar isso aqui agora e ele vai construir esse algoritmo. Agora que o Codex está construindo o código, vou

04:51 pedir ao próprio Claude aqui para chamar o Codex, certo? Em outra sessão, para revisar o código dele. Então, vou simplesmente dizer o seguinte. Olha só: chame o Codex para revisar seu código. Peça a ele que analise, procure problemas e erros e devolva um relatório para você. Então, simplesmente peço isso aqui e envio ao Claude Code. Agora, o Claude Code vai usar o código que mostrei antes, chamando o Codex. E o Codex vai analisar

05:23 o arquivo e devolver a revisão que o Claude Code solicitou. Assim, com essa revisão adversarial, você pode revisar bastante código com dois harnesses conectados entre si, entendeu? Isso funciona muito bem com Claude Code, Codex e Open Code. Infelizmente, não é possível fazer isso com Antigravity. Mesmo com o Antigravity ali, a CLI, certo, o cliente do Antigravity. Infelizmente, o Google não lançou uma forma interessante de chamá-lo. Testei várias vezes e não consegui. Se você conseguir

05:54 fazer isso, deixe nos comentários, porque tenho muito interesse. Entendeu? Mas, por enquanto, ainda não consegui. Repare que ele está chamando aqui e esperando o Codex fazer a análise. Agora que o Codex terminou aqui, vamos fazer o inverso. Vamos pedir ao Codex que chame o Claude Code para analisar o código que ele criou, certo? Então, vou fazer o seguinte aqui. Olha só: vou escrever aqui: peça ao Claude Code para analisar e revisar o código, procurando problemas e pontos a melhorar. Vou enviar isso a ele, e agora o Codex

06:25 vai chamar o Claude Code para pedir a revisão. Isso é muito legal, né? Porque agora também tenho essa abordagem adversarial, em que o Codex tem outra pessoa para dar uma opinião sobre o código dele. Veja aqui: o Codex já encontrou algo, está vendo? Ele está dizendo que o Codex revisou claude.py e encontrou um erro na lógica do algoritmo. Não alterou nenhum arquivo, certo? Mas fez algumas sugestões, né? Ele percebeu ali que há um índice alto sem validação, certo? Problemas que apontou: um problema de alta gravidade, certo? Alta

06:57 gravidade: índice sem validação, certo? Então, encontrou isso e fez uma sugestão de melhoria. Complexidade média: lentidão na ausência de arestas, certo? Baixa gravidade: aceita valores negativos de n. Então, essa é mais uma solução. E baixa gravidade: arestas duplicadas. Aí o próprio Claude Code pergunta: “Quer que eu aplique essas correções?” Você diz que sim se concordar com essa solicitação: sim, aplique as correções. E agora você terá um código corrigido por outra inteligência

07:27 artificial. Essas inteligências artificiais, apesar de terem capacidades parecidas, certo? Foram treinadas com bases de dados diferentes, pessoal. Não há nada igual, exatamente igual, no treinamento dessas redes neurais, certo? Isso é legal porque você tem vários caminhos de redes Transformer percorrendo o mesmo código para procurar problemas. Aqui diz que aplicou as quatro correções relacionadas a índices das arestas, arestas duplicadas e vértices isolados, certo? Diz que testou por força bruta em 500 grafos, certo? Com arestas duplicadas, arestas invertidas e laços, e todos

07:59 produziram o resultado correto. Entradas inválidas também geraram o erro esperado. Então, temos aqui uma avaliação, certo, já positiva em relação ao código do Claude Code. Muito bem, a revisão terminou aqui. Diz o seguinte: o Claude revisou o arquivo e não encontrou bugs funcionais na leitura do código. Considerou corretos o balanceamento, a exclusão e a ligação das folhas. Entendeu? É uma árvore, certo? Então, vamos lá. Mas apontou melhorias. Isso é muito legal. Olha só: desempenho, certo? Chaves personalizadas, memória, certo? E

08:34 compatibilidade. Entendeu? Essas foram as sugestões de melhoria do Claude. E aqui ele pergunta se você quer aplicá-las. Então, vou dizer aqui: aplique essas melhorias. Melhorias. Certo. Faltou uma aqui, então vou enviar para ele. Certo. Aí o Codex diz aqui o seguinte. Olha só: melhorias aplicadas em codex.py, certo? Separadores atualizados sem percorrer as subárvores novamente, certo? Há um novo iterador de intervalo que entrega um registro por vez, e o

09:06 range continua retornando uma lista, certo? Os requisitos para as chaves e para Python foram totalmente documentados. Ele diz que executou quatro testes aqui. Todos passaram, incluindo 24.000 operações aleatórias e verificações de balanceamento. Então, veja com atenção o que quero dizer com tudo isso. Na geração de código por IA, a quantidade de código está se tornando cada vez mais quase impraticável para uma pessoa avaliar. Obviamente, o ideal seria o quê? Você mesmo vir aqui e abrir, certo, o código para entender, certo, o

09:38 algoritmo de Edmonds aqui, entendeu? Ou abrir o Codex aqui, entendeu? E abrir, entender a B+ Tree e verificar se há problemas nesse código, certo? Mas o que está acontecendo é que a quantidade de código está se tornando impraticável para uma pessoa avaliar adequadamente e em tempo hábil. Então, a avaliação humana acaba se tornando um gargalo no processo. E, quando você tem uma avaliação adversarial aqui, desse jeito, como estou ensinando a vocês, com o Codex e o Claude Code, tudo fica muito mais interessante e as coisas ficam

10:14 muito mais rápidas. Entendeu? Bem, espero que tenha gostado deste vídeo. Um grande abraço e até a próxima. M.

Transcrição original

[00:00] Tell me something, do you trust code written by an AI without reviewing it yourself? What if I use another artificial intelligence to try and find errors that went unnoticed during programming? Today, Cloud Code will write some code and Codex will review it, because this is the style I’m using now to create my code. Later, we will swap them. Codex will write some code and Cloud Code will look for the flaws. One builds and the other questions. But

[00:31] will one be able to find the other’s mistake? Or will they both agree on the same incorrect code? That is what we are going to put to the test today. In this video, I will show you how to perform code review using artificial intelligence as well. All right, I have Cloud Code open here on the left side and Codex open here on the right side. Got it? I’m going to ask Cloud Code the following question, look. What terminal command would you use to call Codex in free permission mode? So, if I press enter here, it will return exactly

[01:06] which terminal command I could use to call Codex directly. So, to run Codex, I would call codexe dash iolo. And here is the task, that is, the prompt. So, I’ll take it here, I’ll copy it here, open a new Windows terminal anywhere here, no problem at all. I’ll paste it and in this new task I’ll tell it like this, look. say hello Sandeco. And what will happen then? It will immediately open, right, the terminal here. Did you see what happened? It opened the

[01:40] terminal, right, the communication with the model here in the GPT6 Astra model, Open provider, right, no approval needed and all that. Its reasoning will be high, right? And down here I will say hello, say hello Sandeco. That’s what the user said, in this case me. And here is Codex answering hello Sandeco. All right. Now let’s invert it . I’ll close the terminal here. Actually, I won’t close it. I’ll just run a CLS here to clear the screen. I’ll leave this terminal quiet right here. And now I’m going to invert it, I’ll call Codex at this point and tell it like this, look. What terminal

[02:13] command would you use to call Cloud Code in free permission mode? And then, if I enter here, it will execute this information and bring me the command I could use to call Cloud. All right? Naturally, it will pull from, you know, the official documentation. But you see , you’re going to see that the two harnesses know how to communicate, okay ? So, look, in the same way, right? Cloud main minus minus dangerously ski permissions, right? Eh, OK. And how,

[02:44] and how would I pass the prompt in this command? This, this thing here, this that I’m showing you has a lot, is very useful, because I’m going to show you that very soon we can make the two projects talk to each other. So, if I copy it here now, I’ll go back to the terminal we were using before to execute this command here, only I’m going to say the same command I asked, right? Say hello Sandec. Alright, let’s go. So, now opening the cloud, it

[03:17] called here for execution, it’s going to call, telling it to say: “Hello, Sandeco, hello Sandec”. And then everything’s fine, it worked, it was a beauty, right? Now, what happens is the following. Well, now I’m here in VS Code with Cloud Code and with Codex also open here in a project, okay? And I’m going to ask Cloud Code to write an algorithm. It’s going to be the Edmonds algorithm, okay? Let’s do the following , look. Here I’m going to ask him exactly this, look. Write, right? I’ll put it here at the top. Write a Python

[03:48] program for the Edmonds algorithm, where it finds the largest possible amount of pairs in a network of connections, without using the same participant in two pairs. For example, it allows forming the maximum number of pairs between compatible people, reorganizing previous combinations when this makes it possible to include more participants. This algorithm here, folks, it’s quite annoying to do, a bit complicated. I’m going to tell him here . Besides that, look, name the file cloud.py. I wrote it wrong here, let’s

[04:21] put cloud, right? Let’s go. Tell Cloud to do it. Now I’m going to ask Codex to write the following, look. Write a Python program for a B + tree and organize information in a branching structure that allows searching, inserting, and deleting records efficiently, facilitating range queries . Name the file codex.py. So I’m going to send it here now and it’s going to construct this algorithm. Now that Codex is building its code, I’m going

[04:51] to ask Cloud itself here to call Codex, okay? In another session to review its code. So I’m simply going to say, look, call Codex to review your code. Ask it to analyze, look for problems and errors, and return a report to you. So I simply ask for this here and send it to Cloud Code. Now Cloud Code will use the code I showed you previously, calling Codex. And Codex will analyze

[05:23] the file, returning the review that Cloud Code requested. And so, in this adversarial review, you can review a lot of code with two harnesses connected to each other, get it? This works very well with Cloud Code, Codex, and Open Code. Unfortunately, with Antigravity, it’s not possible to do this. Even with Antigravity there, the CLI, right, the little Antigravity client. Unfortunately, Google hasn’t released an interesting way to call it. I’ve tested it several times and haven’t succeeded. If you manage to do

[05:54] it, put it down there in the description, as I’m very interested in that. Got it? But for now, I haven’t managed it yet, but notice that it’s calling here and waiting for Codex to do its analysis. Now, since Codex finished here, let’s do the reverse. Let’s ask Codex to call Cloud Code to analyze the code it created, right? So I’m going to do the following here, look. I’ll put here: ask Cloud Code to analyze and review the code, looking for problems and areas for improvement. So I’ll send this to it, and now Codex

[06:25] will call Cloud Code asking for the review. So this is really cool, right? Because now I also have this adversarial approach where Codex has another person to give an opinion on its code. See here, look, Codex has already found something, do you see? It’s saying that Codex reviewed cloud.p and found an error in the algorithm’s logic. It didn’t change any file, okay? But it did make some suggestions, right ? It saw there, uh, high index without validation, right? Problems it pointed out, a high problem, right? High

[06:57] problem, index without validation, okay ? So it found that and made a suggestion for improvement. Medium complexity, slowness without edges, okay? Low complexity, negative n accepted. So that is one more solution. And low duplicate edges. And then Cloud Code itself asks: “Do you want me to apply these fixes?” You say yes, if you agree with this request, yes, apply the fixes. And now you will have code that was corrected by another artificial

[07:27] intelligence. These artificial intelligences, despite having similar power, okay? They were trained with different databases, folks. There is nothing equal, exactly the same, in the training of these neural networks, okay ? So this is cool because you have several Transformer network paths traveling through the same code to look for problems. It says here that it applied the four corrections for the edge indices, duplicate edges, and isolated vertices, right? It says it tested with brute force on 500 graphs, right? with duplicate edges, inverted edges, and loops, and all of them

[07:59] yielded the correct result. Invalid inputs also led to an expected error. So, we have an evaluation here, right, already positive regarding the Cloud Code’s code. Very well, the review finished here. It says the following: the cloud reviewed the file and found no functional bugs in reading the code. It considered the balancing, the deletion, and the leaf linking correct. Got it? It’s a tree, right? So let’s go . Uh, but it pointed out improvements. This is very cool, look. Performance, right? Custom keys, memory, okay? And

[08:34] compatibility. Got it? Those were the cloud’s improvement suggestions. And it asks here, right, if you want to apply them. So, I’ll say here, right, apply these improvements. Improvements. OK. One was missing here, so I’ll send it to it here. OK. Then the Codex says here, look: improvements applied in codex.py, right, separators updated, without re-traversing subtrees, okay? Uh, there is a new range iterator that delivers one record at a time, and the

[09:06] range continues returning a list, right ? Requirements for keys and Python were fully documented. It says it ran four tests here. All of them passed, including 24,000 random operations and balancing checks. So, look closely at what I want to say with all this here. In AI code generation, the amount of code is increasingly becoming almost impractical for a human to evaluate. Obviously, what would be ideal? You yourself coming here and opening, right , the code to understand, right, the

[09:38] Edmonds algorithm here, got it? Or opening the Codex here, got it? and opening, understanding the B + Tree, and checking for problems in this code, right? But what is happening is that the amount of code is becoming impractical for a human to evaluate, right, properly in a timely manner. So, human evaluation ends up becoming a bottleneck in the process. And so when you have adversarial evaluation here, in this way, as I am teaching you, the Codex with the Cloud Code, it becomes much more interesting and things become

[10:14] much faster. Got it? Well, I hope you enjoyed this video. A big hug to you and see you next time. M.