This book is written not as a catalog of features but as a working manual, and so every mechanism is examined in the same order. First - what problem it solves, then where its configuration lives and when it loads, then its scope and precedence, how to verify the actual state, what can go wrong and how to safely return the system to a clear configuration. This order matters more than neat generalizations: it turns a set of facts into reproducible understanding.
The text strictly distinguishes two kinds of statements, and this distinction is the basis of trust in the book. The first is marked as official: a fact, a command name, a key, a path, a limit or a precedence order directly described by Anthropic is accompanied by a link to the primary source. The second is an engineering conclusion: a practical recommendation that follows from documented behavior but is not a product requirement. Keeping a shared settings.json minimal is a sensible technique but not a Claude Code rule, and the book separates the two honestly.
The split between the official and the derived matters more than convenient certainty. A setting becomes useful only when you understand three things: where it comes from, what value is allowed and what a mistake costs. A technique presented as an unshakable rule will sooner or later hit a context where it is harmful; the same technique presented as an engineering conclusion from behavior you will apply consciously, where it fits, rather than out of habit.
Completeness in this book means four concrete things. All the main surfaces of Claude Code and their differences. The whole path - from installation to CI/CD and corporate policy. All built-in commands, CLI flags, settings.json keys and hook events, gathered into references. And a full index of documented environment variables, with the working core singled out separately from the diagnostic and cloud switches that are touched rarely.
At the same time, completeness is not a call to enable every flag. Many environment variables exist for support, migrations, cloud providers or emergency diagnostics, and in ordinary work they are not touched. A setting is useful not by the amount enabled but by precision: one consciously set key, whose source and cost are clear, is worth more than ten copied from someone else's config without understanding.
The book's main practical principle is to verify the actual state by command, not from memory. Claude Code changes fast between versions, and behavior learned once may diverge from the current. So every chapter is grounded in verification: claude --version answers what exactly is running, /status which model, provider and directory, /permissions and /context what is actually loaded and allowed. A live command always matters more than confidence from memory.
There is also a baseline safety rule worth internalizing before anything else. The ~/.claude directory, the ~/.claude.json file, the project .claude/ and .mcp.json hold settings, approvals, MCP configurations, transcripts and project state. Deleting them is not part of an ordinary reinstall but a separate destructive operation. Reinstalling the binary deliberately does not touch user configuration, and it is worth relying on that: a backup first, then any deletion.
The book can be read two ways. In order - the chapters run from the checkable foundation to daily work, trust, configuration and operation, and each relies on the previous. Or pointwise - to the mechanism you need, because each chapter is self-contained and ends with how to verify the result and how to return to a clear configuration. At the end there is a short glossary and five references: commands, flags, settings keys, hook events and environment variables.
# Verify state by command, not from memory
claude --version # what exactly is running
claude doctor # installation, settings validity, known issues
# Inside a session - what is actually loaded and allowed:
# /status model, provider, directory, settings sources
# /permissions active mode and rules
# /context memory files and context usage