Anthropic revelou como seus engenheiros usam Claude Code

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: Anthropic Just Revealed How Their Engineers Use Claude Code · Canal: AI LABS · 11:20 · Assistir no YouTube

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

Resumo

O vídeo apresenta as ideias de Felix Reiseberg sobre como obter resultados melhores com Claude Code e outros agentes: definir resultados ambiciosos, em vez de apenas delegar tarefas. Ele explica três abordagens — altitude, profundidade e abrangência — para orientar o agente a trabalhar em um nível mais estratégico, especializado e multidisciplinar. Também recomenda avaliar o trabalho com outro modelo e dar ao agente acesso às ferramentas, aos dados e ao contexto necessários. Ao final, o canal menciona uma skill que reúne essas regras.

Pontos-chave

Peça ao agente o resultado que você quer alcançar, em vez de apenas uma lista de tarefas.
Altitude significa trabalhar em um nível mais abstrato, orientado a um resultado específico.
Profundidade exige métodos, ferramentas e materiais de referência usados por especialistas, não apenas uma instrução para assumir um papel profissional.
Metas ambiciosas podem levar o agente a repensar a solução, em vez de fazer apenas ajustes superficiais.
Use um avaliador externo, de preferência um modelo diferente daquele que produziu o trabalho.
Abrangência consiste em examinar o trabalho por perspectivas de diferentes áreas, usando subagents especializados.
Trocar a descrição do que o aplicativo é pela descrição do que ele faz pode ajudar a identificar perspectivas relevantes.
Agentes precisam de acesso às ferramentas e aos dados, além de contexto e um ambiente para testar se as soluções funcionam.

Capítulos

Início	Capítulo	Resumo
00:00	Por que os agentes entregam resultados comuns	O vídeo introduz a ideia de que agentes tendem a concluir a tarefa pedida, sem necessariamente alcançar o resultado que o usuário deseja.
02:02	Altitude: orientar pelo resultado	Altitude é apresentada como a prática de especificar o resultado esperado e deixar o agente decidir quais tarefas executar.
04:06	Profundidade: trabalhar como um especialista	A seção explica como pedir métodos e ferramentas profissionais e como usar outro modelo para avaliar o trabalho.
08:14	Abrangência: incorporar outras perspectivas	O vídeo propõe usar subagents de diferentes áreas para analisar e melhorar o aplicativo por vários ângulos.
10:18	Dar recursos e contexto ao agente	A conclusão destaca que o agente precisa de dados, contexto, ferramentas e um ambiente de teste para verificar suas soluções.

Citações

As mesmas modelos dão resultados incríveis para algumas pessoas e resultados bem comuns para outras. — 01:01

Você não entrega a próxima tarefa; diz qual é o resultado final que busca e deixa o modelo descobrir as tarefas. — 02:33

Dizer ao modelo para agir como um profissional geralmente muda o tom da resposta, mas não significa que ele fez o trabalho como um profissional. — 05:37

Pedir um resultado maior não ajuda se o agente não tem como saber se chegou lá. — 10:18

Conceitos e entidades

Claude Code (ferramenta): Ferramenta de programação com IA discutida no vídeo como exemplo de agente que pode ser orientado a alcançar resultados mais ambiciosos.
Felix Reiseberg (pessoa): Engenheiro citado no vídeo como autor do artigo sobre como usar agentes de IA para ir além da execução de tarefas.
Anthropic (empresa): Empresa associada a Claude e ao trabalho de engenharia mencionado no vídeo.
altitude (conceito): Abordagem que orienta o agente pelo resultado desejado e deixa que ele determine as tarefas necessárias.
depth (conceito): Abordagem que incentiva o agente a usar dados, métodos e ferramentas de especialistas para executar o trabalho com mais rigor.
range (conceito): Abordagem que analisa o trabalho por perspectivas de diferentes campos e especialidades.
Codex CLI (ferramenta): CLI mencionada como opção para revisar, com um agente separado, uma funcionalidade implementada por Claude.
MCP (conceito): Meio citado para conectar um agente a ferramentas, como sistemas que registram falhas de um aplicativo.
subagent (conceito): Agente especializado que pode examinar um aplicativo sob uma perspectiva específica e propor ou implementar melhorias.
GoLogin (ferramenta): Produto apresentado como patrocinador do vídeo, descrito como um navegador antidetecção com perfis separados.
AI Labs Pro (empresa): Comunidade do canal onde, segundo o vídeo, está disponível uma skill com as regras apresentadas.

Tradução completa (pt-BR)

00:00 Felix Reiseberg, que liderou a engenharia dos aplicativos do Claude na Anthropic, publicou um artigo dizendo que a maioria das pessoas não chega nem perto de aproveitar tudo o que o Claude Code pode fazer e que é preciso ser muito mais ambicioso com ele. Se você já construiu alguma coisa com ele, sabe que ele faz exatamente o que você pede e, segundo Felix, esse é justamente o problema. Então, se o que você constrói com ele sempre parece estar faltando alguma coisa, não é a ferramenta que está impedindo você, e sim a forma como você a trata. Ele divide a maneira como usa o Claude em algumas formas de fazer pedidos, e cada uma muda o que você recebe de volta. Elas vão desde uma pequena mudança na forma como

00:30 você formula seu pedido até um prompt que ele executa antes de o Claude construir qualquer coisa. E a mais minuciosa delas leva muito tempo para ser executada, mas detecta coisas que você nunca pensaria em verificar. E todas funcionam com qualquer agent que você use para construir, não apenas com o Claude Code. Se esta é sua primeira vez aqui, somos uma empresa de software, e este é o nosso canal AI labs. Neste vídeo, vamos mostrar como é, na prática, tratar o Claude Code da maneira certa. Antes de chegarmos aos pontos de Felix, você precisa ver como está tratando a ferramenta agora. No momento, você trata o Claude Code como uma ferramenta à qual basta dar uma tarefa, e ela executa essa tarefa

01:01 para você. E não é que ela não faça isso. Você certamente obtém o que pede, mas Felix observa que os mesmos modelos dão resultados incríveis para algumas pessoas e resultados bem comuns para outras. Quem consegue ótimos resultados não trata a ferramenta como algo que simplesmente executa uma tarefa. Então, por que a mesma ferramenta dá resultados tão comuns para a maioria das pessoas? O problema é que, quando você dá qualquer tarefa a ela, o agent tende a fazer o mínimo necessário. Ele simplesmente termina a tarefa que você deu e considera o trabalho concluído, porque nada no seu prompt explicou o que aquela tarefa deveria proporcionar. E isso não é só

01:32 uma questão de IA. Felix menciona um estudo que descobriu que as pessoas a quem é dada uma meta específica e difícil têm um desempenho melhor do que aquelas a quem simplesmente se diz para executar uma tarefa. E a mesma ideia se aplica quando você dá tarefas ao seu agent de IA. Portanto, a maneira de resolver esse problema é mudar a forma como você o trata. O principal motivo para usar o Claude Code é obter um resultado, não apenas concluir tarefas. É por isso que você precisa tratá-lo como alguém que vai ajudar você a alcançar esse resultado. E é isso que Felix quer dizer quando afirma que você precisa ir além do necessário. Segundo ele, ir além do necessário pode ser dividido em

02:02 quatro tipos. O primeiro é a velocidade, que consiste em fazer o mesmo trabalho em menos tempo, e a maioria das pessoas já faz isso, porque já está construindo com IA em ritmo acelerado. Os outros três são altitude, profundidade e alcance, e são exatamente sobre eles que vamos falar. Mas, antes disso, seria ótimo se você se inscrevesse no canal e apertasse o botão de hype. Esse pequeno gesto de apoio faz uma grande diferença para nós. O primeiro tipo que vamos abordar é a altitude. Para Felix, altitude com agents de IA significa permitir que os modelos operem em um nível mais alto de abstração. Basicamente, isso significa que, sempre que você

02:33 usa um modelo, não deve simplesmente passar a ele a próxima tarefa; deve dizer qual é o resultado final que busca e deixá-lo determinar as tarefas por conta própria. Felix diz que, quando corrigia problemas que faziam o aplicativo travar usando agents de IA, costumava dar a eles um problema de cada vez. Mas agora pede ao agent que garanta que o aplicativo não trave. Digamos que queremos um painel de relatórios para nosso aplicativo. Se simplesmente pedirmos ao Claude que crie um, ele o constrói corretamente, com todos os dados aparecendo no relatório. Mas o relatório que ele costuma fornecer é bem simples e apenas mostra os dados e todos os números. O verdadeiro motivo para pedir um relatório era obter

03:04 algo que permitisse tomar decisões, não apenas números organizados em gráficos. Um relatório precisa ser orientado a resultados, e é exatamente isso que a altitude resolve. Por esse motivo, em vez de simplesmente pedir que ele crie um relatório ou painel, você precisa mencionar no seu prompt o resultado que deseja alcançar, que, no nosso caso, é contratar mais rapidamente. Você precisa pedir que ele apresente os dados de uma forma que não apenas mostre os números, mas também analise os dados e descubra por que o resultado não está sendo alcançado. Você também deve pedir que ele informe quais são os problemas e o que fazer a respeito. Então, o que o Claude realmente

03:35 constrói quando você escreve esse prompt? Quando você dá esse prompt a ele, ele constrói o painel de acordo com as instruções, e você percebe a diferença na aparência. Vai notar que ele se concentra mais em alcançar resultados, em vez de apenas mostrar números. Depois, ele passa aos detalhes principais e mostra as decisões críticas que você precisa tomar. Mas a altitude não serve para tudo. Ela funciona melhor quando há um resultado específico que você está buscando. Funciona menos bem em trabalhos criativos, nos quais não existe um único resultado certo a alcançar. Portanto, a altitude garante que você escreva o prompt para o Claude de modo a obter o que quer, em vez de simplesmente

04:06 concluir a tarefa. E, para levar isso ainda mais longe, entra o segundo tipo. Mas, antes de continuar, vamos falar do nosso patrocinador, GoLogin. Os sites conseguem perceber quando duas contas vêm da mesma máquina e, mais cedo ou mais tarde, uma delas é sinalizada. GoLogin é um navegador antidetecção que resolve esse problema. Você cria um perfil separado para cada conta, e cada perfil tem sua própria impressão digital, cookies e endereço IP, para que cada site veja um dispositivo completamente diferente. Então, vamos testar. Criamos alguns perfis e os abrimos lado a lado, e permanecemos conectados ao mesmo

04:36 site em todos eles, sem que nenhum fosse sinalizado ou associado aos outros. Cada perfil também pode usar seu próprio proxy, e o GoLogin inclui proxies próprios em mais de 100 países, caso você não tenha nenhum, para que possa acessar conteúdo bloqueado onde você está. Você pode até compartilhar um perfil com um colega de equipe sem nunca revelar a senha. Você tem 7 dias de acesso gratuito, além de 40% de desconto na primeira compra e 2 GB de tráfego de proxy gratuito com o código AI Labs Go 40. Assuma o controle da sua privacidade on-line no link da descrição. A segunda coisa de que ele fala é

05:06 profundidade. Por profundidade, ele quer dizer executar uma tarefa da maneira que o melhor especialista da área executaria. Normalmente, o Claude faz o trabalho apenas superficialmente. Por isso, o modelo precisa se aprofundar nos dados, nas ferramentas e nos problemas reais que estão por trás da tarefa, para conseguir fazer um trabalho melhor do que costuma fazer. Então, por que o Claude não se aprofunda por conta própria? Porque seu prompt descreve apenas o recurso, então é só isso que ele constrói. Quando você quer adicionar um recurso ao aplicativo que está desenvolvendo, simplesmente diz a ele qual recurso quer criar, e o Claude o constrói da maneira que você descreveu. E, se quiser que seja feito corretamente, provavelmente acrescentaria ao prompt um papel que

05:37 seja o mais adequado para executar a tarefa. Mas Felix diz que, quando você manda um modelo agir como um profissional, geralmente isso muda o jeito como a resposta soa, mas não significa que ele executou a tarefa da maneira que um profissional executaria. Portanto, em vez de simplesmente pedir ao Claude que aja como determinado profissional, você precisa insistir para que ele use os métodos e as ferramentas que os melhores profissionais daquela área usam. Você não precisa conhecer esses métodos, porque geralmente o Claude conhece. Basta pedir que os use, e Felix compartilha um prompt que faz exatamente isso. Esse prompt reescreve seu prompt original para levar o Claude a se aprofundar no trabalho

06:09 o que você quer que ele faça. Começa dizendo ao Claude que você quer uma versão mais profunda da tarefa, não uma maior, e então lista todos os pontos que ajudam. Pede ao Claude que diga o que um profissional faria que não estamos pedindo, de que material ele deveria partir, quais métodos e ferramentas específicos deveria usar e o que, além de o Claude dizer isso, provaria que o resultado está certo. Você pode copiar o prompt do artigo, que está linkado na descrição, e usá-lo exatamente como está, apenas acrescentando sua própria tarefa. Quando você der esse prompt a ele, ele vai gerar outro prompt com base no contexto do app e em todas

06:40 as instruções que você deu. Você pode então executar o comando de cópia para copiar esse prompt e colá-lo em uma nova sessão. Aí ele começará a implementar e garantirá que todos os detalhes sejam devidamente contemplados. Você precisa dar aos seus agents metas que pareçam quase impossíveis, porque isso os leva a fazer o melhor possível. Felix diz que, em vez de simplesmente pedir aos agents que deixem seu site mais rápido, você deveria pedir que façam o site parecer carregar instantaneamente. Isso leva o agent a deixá-lo o mais rápido possível. Uma meta modesta permite que Claude siga o caminho seguro e ajuste o que já está lá. Uma meta que pareça absurda

07:12 não pode ser alcançada com ajustes, então Claude precisa repensar como o site funciona. Você só precisa levá-lo além da versão fácil. Mas, se você exigir tanto do Claude, como saber se ele realmente chegou lá? É aí que entra um avaliador externo. Felix diz que você nunca deve deixar o modelo avaliar o próprio trabalho, porque foi ele mesmo que tomou todas as decisões nesse trabalho. Você pode usar um modelo separado para isso, pedindo ao Claude que execute o agent desse modelo pelo terminal. Digamos que você queira usar Codex para a revisão. Você pode dar ao Claude um prompt dizendo para usar o Codex CLI instalado no seu ambiente para fazer uma

07:42 revisão aprofundada do recurso que você acabou de implementar e apresentar todas as descobertas. Mas, se não quiser usar Codex, pode simplesmente pedir que ele inicie outra sessão do Claude Code em modo não interativo. Assim, ele inicia uma sessão totalmente nova em segundo plano, orientada pela sua sessão atual, e você não precisa controlar essa sessão por conta própria. Mas tente usar um modelo diferente daquele com que você criou o app. Então, basicamente, quando pedimos que ele use Codex para a revisão, ele começa iniciando o Codex CLI, que retorna as descobertas, e Claude começa a implementar as correções, deixando o

08:14 app muito melhor. Então, a profundidade proporciona uma versão do trabalho no nível de um especialista, mas ainda é a visão de um único especialista sobre seu app, e é aí que entra o terceiro tipo. O terceiro tipo é a amplitude, e consiste em analisar seu trabalho por meio de áreas que normalmente você nunca incluiria. A ideia é que pessoas de diferentes áreas veem o mesmo trabalho de maneiras diferentes. Então, quanto mais delas você incluir, mais problemas serão detectados. E, com IA, você pode incluir muito mais pessoas do que conseguiria incluir de outro modo. Normalmente, quando você cria algo com Claude, há um único modelo analisando o app inteiro de um só ângulo. E, quando as pessoas tentam incluir

08:45 outros pontos de vista, geralmente usam papéis, como pedir a Claude que escreva como um recrutador de alto nível. Como vimos na seção anterior, isso só muda a maneira como Claude fala. Em vez disso, peça que ele faça o que um recrutador de alto nível faz. Mas a parte difícil é saber quais áreas incluir. O truque de Felix para isso é substituir o substantivo pelo verbo. Então, em vez de descrever seu app pelo que ele é, você o descreve pelo que ele realmente faz pelas pessoas, o que facilita bastante para você e Claude identificarem quais áreas têm mais conhecimento sobre como fazer isso. Então, descrevemos nosso app da mesma maneira. Nós

09:16 dissemos a ele que não é apenas um app. Sua função é fazer com que desconhecidos confiem a nós seu próximo emprego e que empresas confiem a nós seus serviços. Então, no seu prompt, primeiro dê esse objetivo ao Claude Code e depois peça que ele analise o app de tantos ângulos quanto conseguir. Para isso, Claude precisa iniciar diferentes subagents, e cada subagent deve trabalhar em uma função especializada específica, com conhecimento das áreas mais relacionadas ao seu app. Então, quando você der esse prompt a ele, será criado um workflow dinâmico com vários subagents executados um após o outro, cada um analisando o app

09:47 por meio da sua própria área. Cada subagent sugere correções e as implementa antes de o próximo começar. A execução demora bastante, porque cada subagent trabalha com base no que o anterior corrigiu, mas, no fim, conseguimos deixar o app em um estado muito melhor. Então, a principal conclusão de tudo isso é que você precisa começar a criar prompts diferentes para seus agents. Seja lá o que você normalmente pediria, peça algo além disso, e é assim que você começa a obter resultados realmente bons o suficiente. Mas a parte mais importante de todas é dar ao seu agent os recursos para realmente fazer isso. Felix diz que cada

10:18 um desses tipos só funciona se o modelo puder instalar o software de que precisa e acessar os dados de que precisa. Pedir um resultado maior não ajuda se o agent não tem como saber se chegou lá. Veja o próprio exemplo de Felix. Para fazer com que Claude mantivesse os apps dele livres de falhas, ele precisou mudar a maneira como trabalha com Claude e forneceu alguns tipos de recursos. Primeiro, os relatórios de falhas, para que Claude pudesse ver quando o app falha. No seu app, isso poderia significar conectar seu agent de IA a qualquer ferramenta que monitore suas falhas por meio de um MCP, para que ele possa ver quando o app falha. Segundo, o contexto para

10:49 entendê-las, o que, para ele, significava saber qual versão do app correspondia a cada alteração no código. E, terceiro, computadores nos quais Claude pudesse reproduzir cada falha e testar a própria correção, para que pudesse provar que ela funcionou, em vez de apenas dizer que funcionou. Então, não se trata apenas de conectar ferramentas. Claude também precisa ver o problema, ter contexto suficiente sobre seu app para entendê-lo e dispor de um ambiente onde possa testar coisas e verificá-las. E, com o contexto certo, as instruções certas e as ferramentas certas, ele vai superar suas expectativas. Agora, criamos uma skill que basicamente reúne todas essas regras de uma forma que

11:20 seus agents sigam essas regras sem que você precise incluí-las explicitamente no prompt. Essa skill está disponível no AI Labs Pro, que é a nossa comunidade. Então, se você encontrou valor no que fazemos e quer apoiar o canal, essa é a melhor maneira de fazer isso. O link está na descrição. E assim chegamos ao fim deste vídeo. Se quiser apoiar o canal e nos ajudar a continuar fazendo vídeos como este, você pode fazer isso usando o botão Super Thanks abaixo. Como sempre, obrigado por assistir, e nos vemos no próximo.

Transcrição original

[00:00] Felix Reiseberg, who led engineering for Claude’s apps at Anthropic, released an article that says most people aren’t getting anywhere near what Claude code can do, and that you need to be way more ambitious with it. If you’ve built anything with it, you know it does exactly what you ask, and according to him, that’s exactly the problem. So, if what you build with it always feels like it’s missing something, it isn’t the tool holding you back, it’s how you treat it. He breaks the way he uses Claude down into a few ways of asking, and each one changes what you get back. They range from a small change in how

[00:30] you word your request to a prompt he runs before Claude builds anything. And the most thorough of them takes ages to run, but catches what you’d never think to check. And all of these work with any agent you use to build, not just Claude code. If this is your first time, we’re a software company, and this is our channel AI labs. And in this video, we’re going to show you what treating Claude code right actually looks like. Before we get to Felix’s points, you need to see how you’re treating it right now. At the moment, you treat Claude code as a tool that you just need to give a task to, and it does that task

[01:01] for you. And it’s not like it doesn’t do that. You sure get what you ask it for, but Felix points out that the same models give some people amazing results, and others very ordinary ones. The people getting great results are the ones who are not treating it like a tool that just does a task. So, why does the same tool give most people such ordinary results? The problem is that when you give it any task, the agent tends to slack off on how well it does it. It just finishes the task you gave it and calls it done, because nothing in your prompt told it what that task was supposed to get you. And this isn’t just

[01:32] an AI thing. Felix mentions a study that found people who are given a specific hard goal do better than people who are just told to do a task. And the same idea applies when you’re giving tasks to your AI agent. So, the way to solve that problem is to change the way you treat it. The main reason you’re using Claude code is to get a result, not just to get tasks done. That’s why you need to treat it as someone who’s going to get you that result. And this is what Felix means when he says you need to go beyond what’s needed. According to him, going beyond what’s needed can be divided into

[02:02] four types. The first type is speed, which is doing the same work in less time, and most people are already doing that because they’re already building with AI at a fast pace. The other three are altitude, depth, and range, and those are exactly what we’re going to talk about. But before that, it would be great if you subscribe to the channel and hit the hype button. This small gesture of support goes a long way for us. The first type that we’re going to go over is altitude. By altitude with AI agents, Felix means letting the models operate at a higher abstraction. This basically means that whenever you’re

[02:33] using a model, you don’t just hand it the next task, you tell it the end result you’re after and let it work out the tasks itself. Felix says that when he was fixing issues that caused the app to crash with AI agents, he used to give them one issue at a time. But now he asked the agent to make sure the app is crash-free. Let’s say we want a reports dashboard for our app. If we just ask Claude to build one, it does build it properly with all the data showing in the report. But the report it usually gives is pretty simple and just shows the data and all the numbers. The real reason you asked for a report was to get

[03:04] something you could take action on, not just numbers laid out in charts. A report needs to be results-driven, and that’s exactly what altitude fixes. So, for that reason, instead of just asking it to build a report or a dashboard, you need to mention in your prompt the result you want to achieve, which in our case is hiring faster. You need to ask it to present the data in a way that doesn’t simply show the numbers, but actually goes through the data and finds out why the result isn’t being achieved. You should also ask it to report what the problems are and what to do about them. So, what does Claude actually

[03:35] build when you prompt it that way? When you give it that prompt, it will build the dashboard accordingly, and you’ll see the difference in the way it looks. You’ll see that it focuses more on getting results instead of just showing you numbers. Then it moves to the key details and shows you the critical decisions you need to make. But altitude doesn’t fit everything. It works best when there’s a specific outcome you’re chasing. It works less well for creative work where there isn’t one right result to aim for. So, altitude make sure you prompt Claude in a way that gets you what you want instead of just getting

[04:06] the task done. And to take this even further, that’s where the second type comes in. But before we move forward, let’s have a word by our sponsor, GoLogin. Sites can tell when two accounts come from the same machine, and sooner or later one of them gets flagged. GoLogin is an anti-detect browser that fixes that. You create a separate profile for each account, and each one carries its own fingerprint, cookies, and IP address, so every site sees a completely different device. So, let’s put it to the test. We spun up a few profiles and opened them side by side, and we stayed signed into the same

[04:36] site on every one of them without anything getting flagged or linked. Each profile can also run through its own proxy, and GoLogin includes its own proxies in over 100 countries if you don’t have any, so you can reach content that’s blocked where you are. You can even hand a profile to a teammate without ever sharing the password. You get 7 days of free access, also 40% off your first purchase, and 2 GB of free proxy traffic with the code AI Labs Go 40. Take control of your online privacy at the link in the description. The second [snorts] thing he talks about is

[05:06] depth. By depth, he means doing a task the way the best expert in that field would. Usually, Claude just gets the work done on the surface. So, instead, the model needs to go deeper into the real data, tools, and problems underneath the task, so it can do better than it normally does. So, why doesn’t Claude go deeper on its own? It’s because your prompt only describes the feature, so that’s all it builds. When you want to add a feature to the app you’re building, you just tell it what feature you want to build, and Claude builds it the way you described it. And if you want it done properly, you’d probably add to the prompt a role that

[05:37] does the task best. But Felix says that when you tell a model to act like a professional, it usually changes how the answer sounds, but that doesn’t mean it did the task the way a professional would. So, instead of just asking Claude to act like a certain professional, you need to keep pushing Claude to use the methods and tools that the best people in that field use. You don’t need to know what those methods are yourself because Claude usually does. You just have to ask for them and Felix shares a prompt that does exactly that. This prompt rewrites your original prompt to push Claude to go deeper into the work

[06:09] you want it to do. It starts by telling Claude that you want a deeper version of the task, not a bigger one, and then lists all the points that help. It asks Claude to say what a professional would do that we’re not asking for, what material it should start from, which specific methods and tools to use, and what other than Claude saying so would prove the result is right. You can copy the prompt from the article, which is linked down in the description, and use it exactly as it is, just adding your own task to it. When you give it that prompt, it will give you another prompt based on the context of the app and all

[06:40] the instructions you gave it. You can then run the copy command to copy this prompt and paste it into a new session. Then it will start implementing and make sure that all the details are properly covered. You need to give your AI agents goals that sound almost impossible because that pushes them to do their best. Felix says that instead of just asking agents to make your site faster, you should ask them to make it feel like the site loads instantly. This pushes the agent to make it as fast as possible. A small goal lets Claude take the safe route and tweak what’s already there. A goal that sounds unreasonable

[07:12] can’t be reached by tweaking, so Claude has to rethink how the site works. You just need to push it past the easy version. But if you push Claude this hard, how do you know it actually got there? That’s where an outside judge comes in. Felix says you should never let the model judge its own work because it made every decision in that work itself. You can use a separate model for this by asking Claude to run that model’s agent from the terminal. So, let’s say you want to use Codex for the review. You can give Claude a prompt telling it to use the Codex CLI that’s installed on your setup to do an

[07:42] in-depth review of the feature you just implemented and give you all the findings. But if you don’t want to use Codex, you can just ask it to spawn another Claude code session in non-interactive mode. This way, it spawns a whole new session in the background that’s prompted by your current session and you don’t need to control that session yourself. But do try to use a different model from the one you built the app with. So basically, when we prompt it to use Codex for review, it will start by spawning the Codex CLI I, which will then return the findings and Claude will start implementing the fixes, making the

[08:14] app much better. So depth gets you one expert level version of the work, but it’s still one expert’s view of your app, and that’s where the third type comes in. The third type is range, and it’s about looking at your work through fields you’d normally never bring in. The idea is that people from different fields see the same job in different ways. So the more of them you bring in, the more problems get caught. And with AI, you can bring in way more of them than you ever could. Normally, when you build with Claude, it’s one model looking at your whole app from one angle. And when people try to bring in

[08:45] other points of view, they usually use roles like telling Claude to write like a top recruiter. As we saw in the previous section, that only changes how Claude talks. So you ask it to do what a top recruiter does instead. But the hard part is knowing which fields to bring in at all. Felix’s trick for this is to replace the noun with a verb. So instead of describing your app by what it is, you describe it by what it actually does for people, and that makes it a lot easier for you and Claude to see which fields know the most about doing that. So we described our app the same way. We

[09:16] told it that it isn’t just an app. Its job is to get strangers to trust us with their next job and get companies to trust us with their services. So in your prompt, you first give Claude code that goal and then ask it to look at the app from as many angles as it can. For that, Claude needs to spawn different sub-agents, and each sub-agent should work on an individual specialized role that knows the fields related to your app best. So, when you give it that prompt, it will spawn a dynamic workflow with multiple sub agents that run one after another, each looking at the app

[09:47] through its own field. Each sub agent suggests fixes and implements them before the next one starts. It takes a really long time to run because each sub agent works on what the previous one fixed, but at the end, we actually get the app into a much better state. So, the main thing to take away from all of this is that you need to start prompting your agents differently. Whatever you’d usually ask for, you ask for what’s beyond it, and that’s how you start getting results that are actually good enough. But, the most important part of all is giving your agent the resources to actually do that. Felix says every

[10:18] one of these types only works if the model can install the software it needs and reach the data it needs. Asking for a bigger result doesn’t help if the agent has no way to see whether it got there. Take Felix’s own example. To get Claude to keep his apps crash free, he had to change the way he works around it, and he gave kinds of things. First, the crash reports, so it could see when the app crashes. For your app, that could mean connecting your AI agent to whatever tool tracks your crashes through an MCP, so that it can see when the app crashes. Second, the context to

[10:49] understand them, which for him meant knowing which version of the app matches which change in the code. And third, computers where it could recreate each crash and test its own fix, so it could prove the fix worked instead of just saying it did. So, it’s not only about connecting tools. Claude also needs to see the problem, enough context about your app to understand it, and a place where it can try things and check them. And with the right context, the right instructions, and the right tooling, it will surpass your expectations. Now, we have created a skill that basically contains all these rules in a way that

[11:20] your agents would follow these rules without you having to explicitly prompt it. This skill can be found in AI Labs Pro, which is our community. So, if you found value in what we do and want to support the channel, this is the best way to do it. The link’s in the description. That brings us to the end of this video. If you’d like to support the channel and help us keep making videos like this, you can do so by using the super thanks button below. As always, thank you for watching and I’ll see you in the next one.