Anthropic Just Revealed How Their Engineers Use Claude Code

0:00Felix 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,

0:27and each one changes what you get back. They range from a small change in how 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

0:49Claude 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 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

1:18results? 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 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

1:48code 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 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

2:17great 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 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

2:47asked 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 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

3:16need 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 build when you prompt it that way? When you give it that prompt, it will build the dashboard accordingly, and you'll

3:40see 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 the task done. And to take this even further, that's where the second type comes in. But before we move forward,

4:11let'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 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

4:43proxies 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 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

5:16real 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 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

5:46did 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 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

6:17Claude 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 the instructions you gave it. You can then run the copy command to copy this

6:44prompt 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 can't be reached by tweaking, so Claude has to rethink how the site works. You

7:16just 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 in-depth review of the feature you just implemented and give you all the

7:46findings. 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 app much better. So depth gets you one expert level version of the work, but

8:19it'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 other points of view, they usually use roles like telling Claude to write like

8:49a 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

9:11fields know the most about doing that. So we described our app the same way. We 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

9:42with multiple sub agents that run one after another, each looking at the app 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

10:14all is giving your agent the resources to actually do that. Felix says every 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

10:44through an MCP, so that it can see when the app crashes. Second, the context to 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

11:09where 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 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

11:39videos 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.