Claude Code rewards investment. Out of the box it is a capable coding agent in your terminal, and most people stop there, typing requests and accepting edits. But the developers who get the most out of it treat it like any serious tool: they configure it, build habits around it, and learn where the sharp edges are. This is the working list of what actually matters, from people who run it all day. No affiliation with Anthropic here, just mileage.
Write a real CLAUDE.md
The best minute you can spend, per unit of payoff, goes to your CLAUDE.md file. Claude Code reads it automatically when it starts working in your project, which makes it the place to record everything you are tired of repeating: how to run the tests, which package manager the project uses, naming conventions, directories to leave alone, the deploy step that bites newcomers.
The failure mode is writing it like documentation for humans. Write it like instructions for a sharp new teammate with no context. Short, imperative, specific. "Run tests with npm test, never npx jest directly" beats three paragraphs about your testing philosophy. And prune it when things change, because a stale CLAUDE.md confidently teaches the agent your old mistakes.
You can also keep a global one in your home directory for preferences that follow you across every project, and drop additional CLAUDE.md files in subdirectories of a monorepo where conventions differ.
Use plan mode for anything nontrivial
Claude Code has a plan mode in which it researches your codebase and proposes an approach before touching any files. For a one-line fix it is overkill. For anything involving multiple files, a migration, or a design decision, it is the difference between reviewing a plan and reviewing a surprise.
The habit that works: describe the task, read the plan critically, and push back in plain language before approving. Correcting a plan costs one sentence. Correcting a half-finished implementation costs an afternoon. The plan is also where you catch the agent misunderstanding your architecture, which is much cheaper to fix as a paragraph than as a diff.
Build your own slash commands
The built-in slash commands cover session mechanics, and a few deserve muscle memory. /clear resets the conversation when you switch tasks, which keeps stale context from bleeding into new work. /compact summarizes a long session to reclaim context when a conversation has gone on for a while. /resume brings back a previous session with its context intact, which is how you pick up yesterday's half-finished refactor without re-explaining it.
The real unlock is custom commands. Drop a Markdown file into your project's .claude/commands directory and it becomes a slash command containing whatever prompt you wrote. Every team has rituals: writing a PR description a certain way, running a pre-review checklist, scaffolding a new endpoint. If you type the same instructions twice a week, that is a command file waiting to exist.
Delegate to subagents
Subagents are separate agents that Claude Code can spin up for a scoped task, each with its own context. The practical benefit is focus in both directions. A subagent digging through your codebase for how authentication works does not fill your main conversation with every file it read, and your main session's history does not distract the subagent from its errand.
They shine for search-and-summarize work, for running independent tasks in parallel, and for role-specific work if you define custom agents with their own instructions. The mental model that helps: your main session is the engineer, subagents are the interns you send to go find things out. Send them liberally.
Learn the permission modes on purpose
Claude Code asks before doing things that affect your system, and how much it asks is configurable. The default mode confirms actions with you. Accept-edits mode lets file edits through without a prompt, useful when you are iterating fast inside a project you trust. Plan mode, as above, is read-only research until you approve a plan. There is also a mode that skips permission prompts entirely, which is best reserved for sandboxed or containerized environments where the blast radius is contained.
The tip is to choose deliberately rather than mashing accept. Escalate freedom as trust grows within a session, and drop back to stricter confirmation when the agent is working somewhere delicate. You can also allowlist specific tools and commands in your settings so routine actions stop prompting while unusual ones still do.
Connect your tools with MCP
Out of the box, Claude Code sees your filesystem and your shell. The Model Context Protocol extends that reach. MCP servers let the agent talk to external systems, issue trackers, databases, browsers, documentation sources, whatever someone has built a server for, and the ecosystem has gotten broad.
The advice here is restraint. Every connected server adds capability the agent has to reason about, and a kitchen-sink configuration gets noisy. Connect the two or three integrations that map to your actual daily flow. For most developers that is the issue tracker and not much else. You can always add more when a task genuinely needs it.
Small habits that compound
A few loose ends that pay rent. Interrupt early: if you can see the agent heading somewhere wrong, stop it and redirect rather than letting it finish and cleaning up. Be specific about done: "make the tests pass" gives the agent a checkable goal in a way "fix the bug" does not. Ask it to write tests first when you care about correctness, because a failing test is the cheapest spec you will ever write.
And keep notes on what works. The developers who are best with these tools treat their setup as a living system: the CLAUDE.md grows, the command files accumulate, the permission settings get tuned. None of it is glamorous. All of it compounds. That is daily driving.
