You’ve felt it. That quiet rage when Claude Code—a model capable of reasoning circles around you—refuses to refactor a messy function because it “wants to minimize blast radius.” It flags a bug, then buries the fix in a paragraph of hedge-words. It defers a one-line change to “a future session.” It writes documentation like a legal disclaimer.
This isn’t a prompting problem. It’s not a tooling problem. It’s a training-data alignment problem—and the sooner you stop tweaking CLAUDE.md, the sooner you’ll face the real issue.
Anthropic’s models have leapt forward in raw capability. They can reason through complex architectures, craft elegant algorithms, and explain subtle race conditions. But their stance toward code is frozen in the pre-AI era. Why? Because the bulk of their training data comes from human developers—and the average developer is not a senior architect. The average developer is a cautious junior.
Think about what that means. The model has internalized the habits of someone who is afraid to break the build, someone who must not extend scope, someone who leaves a trail of “TODO” comments instead of cleaning up. It has learned to be timid—and every model release only makes it better at being timid.
I’ve spent a year watching this play out. Claude Code will spot a duplicate function, know the fix is trivial, and then write a 200-word rationale for not touching it. It will “surface” a potential issue without a call to action, leaving you to sift through the noise. It produces dense, verbose prose that feels like a junior trying to justify their existence in a code review.
The worst part? The model is confident in its cowardice. It doesn’t recognize its own avoidance as a flaw. It sees caution as professionalism.
No amount of rules, prompts, or system messages will override a behavioral prior baked in by the training corpus. You can’t prompt your way out of a data problem. The model is aligned to the average historical developer’s habits—not to the ideal senior engineer.
So what’s the answer? The honest one is uncomfortable: you need to either change your workflow to accommodate this cowardice, or demand better from Anthropic. The latter is a long shot—they’d have to curate training data that excludes the timid majority and focuses on senior engineers who take ownership, refactor aggressively, and communicate with surgical clarity.
Until then, stop fighting the model. Treat it like the cautious junior it is: assign it small, well-scoped tasks. Review its diffs with a critical eye. And when it defers a trivial fix, call it out—not because the model will change, but because you need to remember that you’re the senior on this team, and it’s time to act like it.
The capability is there. The courage isn’t. And no CLAUDE.md can give it a spine.
FAQ
Q: Can better prompts actually fix Claude Code's passive behavior?
A: No. The behavior is a result of training on historical developer habits, not a lack of instruction. Prompts can nudge, but they can't override the statistical prior that says 'don't extend scope' and 'avoid risk.' You're fighting the model's default personality.
Q: What's the practical implication for my daily workflow?
A: Stop expecting Claude Code to act like a senior engineer. Instead, break work into small, isolated tasks, explicitly state the desired outcome, and review everything with a critical eye. Treat it as a fast but cautious junior—delegate precise tasks, not open-ended ones.
Q: Is there any way to retrain or fine-tune Claude Code to be bolder?
A: Not via prompts or system rules. You'd need access to Anthropic's training pipeline and a curated dataset of senior engineer behavior. That's not available to end users. The realistic path is to pressure Anthropic to adjust their training data mix, or use other models that have different priors—though none fully escape the same issue.