Anthropic analyzed 400,000 Claude Code sessions, and it turns out there's a right way to use it

With just how many self-proclaimed AI experts there are out there and the sheer amount of advice now surrounding how you should be using tools like Claude Code, it can be hard to tell what actually works and what’s just another person confidently sharing their preferred workflow. Anthropic, though, has something a tad bit more useful than anecdotes. While the company and its engineers are big on sharing their own Claude Code tips, Anthropic also analyzed around 400,000 real Claude Code sessions to see how people actually use the tool. In addition to finding out the kinds of tasks people are handing over to Claude Code, the research also revealed some clear patterns in what separates the users who get the most out of it from everyone else. You need to stop micromanaging Claude Code You decide what, Claude decides how If you've been using Claude Code or other AI assistants for a while now, there have likely been times where you have dropped a task into the chat and then spent the next few prompts telling it exactly how to complete it. You walk it through exactly which file to open, what part of the code to change, what command to run next, and essentially babysit it through the entire process step by step. When you think about this in hindsight, you're essentially micromanaging the tool instead of actually delegating the task. This is precisely what Anthropic suggests you shouldn't be doing. Instead, the data points toward a much clearer division of labor between you and Claude. You're the one who decides exactly what needs to happen, while Claude figures out what it needs to do to make the task happen. Anthropic found that users made roughly 70% of the planning decisions across the sessions it analyzed, while Claude made around 80% of the execution decisions. In other words, users were largely responsible for deciding what needed to be done, which approach made sense, and what a successful result should look like. Claude, meanwhile, handled most of the actual implementation, such as deciding which files to edit, what code to write, and which commands to run. That's a pretty good blueprint for how you should be using Claude Code in the first place: set the direction, give it the context and constraints it needs, and then let it do the actual work. This approach has benefits that span further than just getting better results, ideally. Anthropic's research suggests that the amount of work Claude gets done between check-ins is closely tied to how much control you hand over to it. Across the sessions analyzed, a typical user prompt triggered a chain of around 10 actions from Claude, which could include reading files, editing code, and running commands. In some cases, that number stretched beyond a hundred. The difference became particularly noticeable depending on who was handling the execution. When users retained more than 80% of the execution decisions themselves, Claude took around eight actions per turn. In comparison, when Claude was given greater control over the session, it was able to run considerably further before needing the user again. In sessions where Claude made more than 80% of the planning decisions, for instance, it took around 16 actions per turn. Now, that doesn't necessarily mean you should hand absolutely everything over to Claude and hope for the best. But it does reinforce the broader point: the more you micromanage every individual step, the less room you're giving Claude Code to actually behave like the agent it's designed to be. For instance, say you're beginning a Claude Code session to optimize your operating system. Instead of telling Claude exactly which folders to inspect, which commands to run, and which processes to check one by one, you could simply explain the end goal, what you're trying to improve, and any constraints it needs to keep in mind. You need enough expertise to steer Claude You still need to know what good looks like By now, you're likely surrounded by people telling you that AI-assisted coding is going to completely change who gets to build software. To an extent, that's already (unfortunately) true. Tools like Claude Code have lowered the barrier to entry significantly, and you no longer need years of programming experience to turn an idea into something functional. However, Anthropic's research suggests there's still one thing you can't really outsource: knowing enough about the problem you're trying to solve. This means that a user's expertise still holds a lot of weight. Anthropic found that users who got the most out of Claude Code were better at framing precise instructions, knowing what needed to be verified, and catching Claude when it went in the wrong direction. In other words, you don't necessarily need to know exactly how to implement a solution yourself, but you do need enough domain knowledge to recognize what a good solution should look like and when Claude has missed the mark. Anthropic also explained that the "expertise" it's referring to here is different from a "job title or general ability." One example it cited was an accountant who may not know how to write Python themselves, but still understands the reconciliation rules a script needs to follow and can spot when Claude mishandles an edge case. In that scenario, the accountant may still be the expert in the session, despite not being the one who knows how to actually write the code. Similar to the micromanaging point above, Anthropic's research suggests that the expertise of the user also affects just how much Claude is able to get done from a single prompt. In typical novice sessions, each prompt triggered around five Claude actions and roughly 600 words of output. In expert sessions, that jumped to around 12 actions and 3,200 words of output. The gap held across different kinds of work and different task-value bands, which suggests this wasn't simply because experts were giving Claude bigger or more complicated jobs. Instead, the more likely explanation is that experienced users were simply better at giving Claude enough context, direction, and room to work without needing to step in constantly. Give Claude a way to verify its own work A thumbs-up from Claude isn’t enough One piece of advice that Claude Code's creator and the engineers working on it have repeatedly emphasized is the importance of giving Claude some way to verify its own work. Interestingly, Anthropic's research into real Claude Code sessions seems to reinforce exactly why that matters. When Anthropic classified users by expertise, it didn't just look at how well they framed their initial instructions. It also looked at how they verified Claude's work afterward. At the novice end of the spectrum, verification tended to be fairly generic, with prompts along the lines of "please double-check," "are you sure?" or simply asking Claude to verify its work. Anthropic doesn't really treat those kinds of prompts as evidence of expertise. After all, you're essentially asking Claude to judge whether Claude did a good job. As users became more experienced, those checks got considerably more specific. Intermediate users mixed generic checks with targeted ones, while advanced users were more likely to ask Claude about a particular mechanic or piece of state. Anthropic gives examples like asking Claude to show how it set a particular configuration, whether it actually called a specific function, or what the cardinality of a join is. At the expert level, that gets even more deliberate, with users anticipating edge cases and designing tests around specific ways the implementation could fail. So rather than ending a prompt with "double-check your work," you're much better off thinking about what would actually prove that the task succeeded. If Claude is fixing a bug, give it a test that reproduces the bug and make sure that test passes afterward. If it's changing a UI, give it a reference and a way to inspect the result. If it's modifying a configuration, have it show you the resulting state. The more objective the feedback loop is, the less you're relying on Claude simply telling you that everything looks fine. Don’t give up when Claude gets it wrong The real skill is getting Claude back on track Something I, and I'm sure most people reading this article, have done before is simply give up on a Claude Code session once it starts going badly enough. Maybe it keeps failing the same test, misunderstands what you're asking for, or somehow manages to make the problem worse with every attempt. At some point, starting over from scratch can feel easier than trying to untangle whatever mess the session has turned into. Anthropic's research suggests that this is another area where more experienced users behave differently. When sessions showed clear signs of trouble, expert users were much more likely to recover and still reach a successful outcome, while novice users were considerably more likely to abandon the session altogether. Among sessions where Anthropic found verified evidence of failure, only around 4% of novice sessions ultimately reached verified success. For expert users, that figure climbed to roughly 15%. The gap was just as noticeable when looking at partial success, with novice users reaching it in around 60% of troubled sessions compared with roughly 80% for intermediate users and above. Novice users were also far more likely to simply give up. Around 19% of troubled novice sessions were abandoned, compared with only around 5% to 7% for everyone else. That suggests one of the most useful skills you can develop with Claude Code isn't preventing every mistake from happening in the first place, but learning how to recognize what's gone wrong and give Claude enough direction to recover from it. The good news is that Anthropic's research doesn't suggest you need to become some sort of Claude Code power user to see most of the benefit here. The biggest jump in success came between novice and intermediate users, while the gains between intermediate and expert users were much smaller. Ultimately, simply developing a decent working understanding of the problem you're trying to solve may already be enough to make a meaningful difference!