The Feature Most People Never Set Up
Five hundred hours in Claude Code, and the single most underused feature is one you configure once in about ten minutes: the CLAUDE.md file.
Drop a file called CLAUDE.md in the root of any project directory. Claude Code reads it at the start of every session. Your coding standards, your architecture decisions, your preferred patterns, your naming conventions, the specific libraries you're using and why. All of it. Inherited automatically, every time, without you having to re-explain anything.
Most developers open Claude Code and immediately start from scratch each session, re-contextualizing the codebase, re-stating preferences, re-explaining decisions that were made three weeks ago. CLAUDE.md ends that. Write it once. Every session starts informed.
The contents that matter most: your architecture constraints ("all database access through the repository layer, no direct queries from controllers"), your style rules ("TypeScript strict mode, no any types, prefer named exports"), and your known gotchas ("the auth middleware has a race condition we're tracking in issue #347, don't refactor it without reviewing that thread first"). The more specific the content, the more it pays back. A CLAUDE.md with three real constraints outperforms one with ten generic preferences.
Slash Commands and the Ones You Should Build
Claude Code ships with slash commands: /review triggers a code review pass, /test generates tests for the current file, /refactor proposes a cleaner version of a selected function. These are useful. They are also just the defaults.
The real value comes from custom slash commands tuned to your specific workflow. One pattern that works well: /onboard, which runs a full environment setup sequence for new contributors, walking through every configuration step with the project's specific requirements. Another: /audit, which runs a security-focused pass across a specified module, flagging common vulnerability patterns your team has agreed to watch for.
The command definitions are simple and live in your project config. The time investment is maybe 30 minutes to define three or four commands that reflect your actual workflow. The payoff is that every session starts with a consistent set of actions available, without having to type the same long instructions repeatedly.
Custom commands also encode organizational knowledge. A junior developer on the team can run /review-migration and get a review that reflects the same checklist a senior engineer uses, without the senior engineer being in the room. The knowledge lives in the command definition, not in any individual's head.
Parallel Worktrees: Running Multiple Sessions Without Chaos
Git worktrees let you check out multiple branches of the same repository into different directories simultaneously. Claude Code is fully compatible with this setup, which means you can run completely separate Claude Code sessions on the same codebase without interference.
Session one: refactoring the authentication module. Session two: writing tests for the payment service. Session three: updating API documentation. All running at the same time, on different branches, on different parts of the codebase. None of them stepping on each other.
This is not a niche use case. Any project where you're working on multiple tracks in parallel benefits from this. The alternative, switching between tasks in a single session, means constant context switching and context bloat as the session carries information from all three tracks simultaneously. The refactoring context bleeds into the documentation work. The test-writing context colors how the model interprets the auth module.
Separate sessions stay focused. The worktree for the authentication refactor knows only about the authentication refactor. Clean scope, clean output. Set up worktrees once and your parallel workflow stops colliding with itself.
The --continue Flag and Context Across Sessions
The --continue flag is how you pick up exactly where you left off. Not approximately. Exactly. The full context of what was decided, what was tried, what was discarded, and why.
Without it, closing a terminal and reopening Claude Code means starting over. Useful context dies when the session ends. The model has no memory of the debugging path you walked through, the approaches you ruled out, or the architectural decisions you landed on. With --continue, the session resumes with the full prior conversation intact, including the reasoning behind intermediate decisions, not just the code changes themselves.
The practical use: long debugging sessions that span multiple sittings. Complex refactoring projects that take multiple days. Any work where the "why" of intermediate decisions matters as much as the code itself. A session where you spent three hours narrowing down a race condition has context that's genuinely valuable to carry forward. --continue carries it.
Combine this with CLAUDE.md and you have a system where context accumulates rather than resets. The project-level context lives in the file. The session-level context persists across terminals. Both together mean Claude Code functions less like a tool you pick up for a question and more like a collaborator with memory of the work.
Headless Mode and CI/CD Integration
Claude Code can run without a human in the loop. Headless mode accepts a task via command line, executes it, and returns output, all without an interactive terminal session. This is where the tool stops being something you use and starts being something you deploy.
The CI/CD applications are direct. Automatic code review on every pull request, triggered as part of the pipeline. Test generation for new functions, run as a post-commit hook. Documentation updates triggered when the public API surface changes. Dependency audit on every merge to main. All of this without anyone manually opening Claude Code.
The setup requires care around permissions and cost controls. An unbounded Claude Code call in a CI pipeline can be expensive if the task scope expands unexpectedly. Setting clear task constraints in the command, capping token usage per run, and monitoring cost per pipeline stage are all necessary before shipping this to production.
Done carefully, this turns Claude Code from something you open when you have a question into background infrastructure that monitors your codebase continuously. Not a flashy capability. Genuinely useful at scale.
Context Management: The Hidden Skill
The context window is finite. Most users fill it up and start over. Power users manage it actively, and the difference in output quality is significant and consistent.
The core practice: /compact before switching to a different part of the codebase. This compresses the current session history into a dense summary, freeing context space without losing important decisions. Then a clean context reset before starting work on an unrelated module.
The reason this matters: context pollution is real. If you spent the first half of a session refactoring error handling and then ask about database optimization, the model's responses are colored by the error-handling context even when it's irrelevant. A fresh context for a fresh task produces sharper output.
The discipline: prune before switching tasks, compact before context fills completely, reset when the work changes enough that prior context is no longer helpful. Fifteen seconds of maintenance that pays back in output quality throughout the rest of the session.
Multi-File Awareness and Coordinated Changes
One of the things that separates Claude Code from a sophisticated autocomplete is its ability to move through a large codebase and make coordinated changes across 10 to 15 files in a single session.
A refactoring task that touches multiple layers of a codebase, say renaming a core data model and propagating that change through all the service classes, controllers, tests, and documentation that reference it, is the kind of work where most tools break down. They make the change in one place and miss it in three others. Claude Code, when given clear scope and a well-structured CLAUDE.md to work from, handles this kind of coordinated multi-file work reliably.
The key practice: give it explicit scope. "Refactor the UserAccount model, update all files in /services, /controllers, and /tests that reference it, and update the API documentation in /docs/api" is a better instruction than "refactor UserAccount." Explicit scope bounds the task and reduces the chance of changes landing in unexpected places.
Custom Hooks and the Always-On Version
Custom hooks bind Claude Code actions to filesystem events. On file save, on test failure, on git commit. The result is a version of Claude Code that doesn't wait for you to ask it something.
A save hook that runs a quick review pass on the changed file and surfaces obvious issues before you context-switch. A test-failure hook that immediately starts diagnosing the failing test and proposes a fix. A pre-commit hook that checks for patterns your team has flagged as risky and blocks the commit with an explanation if it finds them.
This is the shift that matters most. Claude Code configured with hooks stops being a question-answering tool and becomes a background process that monitors your work. Persistent. Proactive. Quiet until it has something useful to say.
The setup time for a basic set of hooks is an afternoon. The payoff is that you stop catching certain classes of errors in code review and start catching them at the moment they're introduced, in the same file, on the same save.
Set up the CLAUDE.md file first.
Everything else builds on that foundation.