The Mental Model
What this gives you: A clear understanding of what Claude Code can actually do for your business. This isn't a chatbot - it reads your files, runs your commands, connects to your tools, and works in parallel. Once you get this, everything else clicks.
The biggest mistake people make with Claude Code is treating it like a chatbot. It is not. Understanding what it actually is - and what it can actually do - is what separates people who get 10x leverage from people who get marginal value.
Stop Thinking Chatbot. Start Thinking Junior Developer.
ChatGPT and Claude.ai are chatbots. You type, they respond with text. The conversation happens entirely in a message thread. They cannot touch your filesystem, run commands, make API calls, or deploy anything. They can only write text that you then go and execute yourself.
Claude Code is fundamentally different. It is a software agent that runs on your machine with access to your actual environment. The correct mental model is not "AI chatbot" - it's "a skilled junior developer sitting at your keyboard who can work autonomously on tasks you delegate."
That junior developer can:
- Read and write any file on your filesystem
- Run shell commands (npm install, git commit, python scripts, anything)
- Make HTTP requests to external APIs
- SSH into remote servers and run commands there
- Spin up dev servers and test them
- Deploy code to Vercel, Netlify, or any cloud provider
- Search your entire codebase simultaneously
- Read your git history to understand why decisions were made
The key shift: you are not using Claude Code to get answers. You are using it to get work done.
What Claude Code Can Actually Do
Here are concrete examples of tasks you can hand off entirely - not just get help with, but fully delegate:
File Operations
Shell Commands
Git Operations
Remote Server Access
The Three Layers of Claude Code
Understanding the architecture of Claude Code helps you know where to configure things and why certain setups are more powerful than others. There are three layers:
Layer 1: CLAUDE.md - The Brain
This is the persistent memory and instruction set. It's what Claude reads at the start of every session to understand who you are, what tools are available, what mistakes to avoid, and how to behave. Without a CLAUDE.md, every session starts from zero. With one, every session starts with full context.
Think of this layer as the onboarding document. Everything about your working style, your environment, your rules, and your history lives here.
Layer 2: MCP Servers - The Hands
MCP (Model Context Protocol) servers are plugins that extend what Claude Code can interact with. Without MCP servers, Claude can only work with your local filesystem and shell. With them, it can reach out to external services as if they were part of your local environment.
Common MCP servers worth setting up: Google Calendar, Notion, Trello, GitHub, Stripe, Slack. Each one multiplies what Claude can accomplish autonomously.
Layer 3: Skills - The Muscle Memory
Skills are reusable instruction files stored in ~/.claude/skills/. A skill is a detailed playbook for a complex, repeatable task. Instead of explaining the same multi-step workflow every time, you write it once as a skill and invoke it with a slash command.
Skills handle the complexity so your prompts stay simple. They're the difference between knowing how to do something and having the muscle memory to do it instantly.
The Context Window and How It Works
The context window is the working memory of the model - the total amount of text (your conversation + all file contents Claude has read + all command outputs) it can hold at once. Claude Opus 4 has a 200,000 token context window. That sounds large, but it fills up faster than you expect when Claude is reading multiple large files and running several commands.
Practical implications:
| Practice | Why It Matters |
|---|---|
| Read specific files, not entire directories | If you ask Claude to "look at my codebase," it will try to read everything. Instead, direct it: "look at src/auth/login.ts." |
| Use /compact when sessions get long | The /compact command summarises the conversation history to free up context space without losing the thread. |
| Fresh sessions are sometimes better than long ones | For a new, unrelated task, starting a fresh claude session gives Claude a clean slate and maximum available context. |
| One-shot mode keeps context minimal | claude -p "task" uses only what's needed for that single task - no session overhead. |
Interactive vs One-Shot Mode: When to Use Which
This is one of the most practical decisions you'll make repeatedly. Here's a clear framework:
Use Interactive Mode (claude) when:
- You're doing exploratory work and don't know exactly what you need yet
- The task requires back-and-forth iteration ("try this... ok now change that...")
- You're debugging something and need to investigate multiple possibilities
- The task will take 30+ minutes of sustained work
- You want to review Claude's work at each step before it continues
Use One-Shot Mode (claude -p) when:
- The task is clearly defined and self-contained
- You want to pipe the output into another command or file
- You're scripting or automating a workflow
- You need the same task run repeatedly (cron jobs, CI pipelines)
- You want to keep your main terminal session clean
Claude Code vs ChatGPT / Regular Claude: The Real Difference
| Feature | Claude.ai / ChatGPT | Claude Code |
|---|---|---|
| Reads your files | No | Yes |
| Runs shell commands | No | Yes |
| Writes files | No | Yes |
| Makes API calls | No | Yes |
| Accesses git history | No | Yes |
| Deploys code | No | Yes |
| SSHs into servers | No | Yes |
| Persistent memory | No (per session) | Yes (CLAUDE.md) |
| Works autonomously | No | Yes |
| Costs per token | Yes | Yes |
The other AI tools are conversational. Claude Code is operational. If you find yourself copy-pasting code from Claude.ai into your editor, running it, then copy-pasting the error back - you're doing it the slow way. Claude Code eliminates that loop entirely.
How Claude Code Reads Your Codebase
When you start a Claude Code session in a project directory, Claude automatically reads several things before you even type your first message:
| What Claude Reads | Purpose |
|---|---|
| CLAUDE.md (global, then project-level) | The instruction set - your rules, preferences, and context |
| Directory structure | A high-level map of what's in the project |
| package.json / pyproject.toml / go.mod | Dependencies and scripts |
| README.md (if present) | Project overview |
It does not read every file immediately (that would burn through your context window). Instead, it reads files on demand as it needs them to complete your task. When you ask it to "fix the login bug," it reasons about which files are likely relevant and reads those specifically.
Sub-Agents and Parallel Work
One of the most powerful (and least-used) features of Claude Code is the ability to spawn sub-agents - separate Claude instances that work on specific sub-tasks in parallel. This is particularly valuable for research, QA, and complex multi-part builds.
The core pattern is "fan out, fan in":
Practical use cases for sub-agents:
| Pattern | How It Works |
|---|---|
| Developer + QA | One agent builds the feature, a fresh agent with no context reviews and tests it. The fresh agent catches assumptions the builder missed. |
| Research parallelisation | Research 5 different APIs simultaneously instead of sequentially - each agent goes deep on its specific topic. |
| Stochastic consensus | For strategy decisions, spawn multiple agents with slightly different framings. Where 3+ agents agree, you have high confidence in the answer. |
Token Costs and How to Think About Them
Claude Code uses the Claude API, which charges per token. Here's how to think about this practically:
The right way to think about cost is not "this costs money" but "what is this worth to me?" If a 2-hour task that would cost you $150 of your time can be done by Claude Code in 10 minutes for $3, that's a 50x return on the spend.
Strategies to keep costs reasonable without sacrificing quality:
| Strategy | How It Reduces Cost |
|---|---|
| Use one-shot mode for scripted, repeatable tasks | Cheaper than interactive sessions because there's no conversation overhead. |
| Use /compact in long sessions | Compresses history and reduces input tokens on all subsequent messages in the session. |
| Be specific about what to read | "Read src/auth.ts" is cheaper than "look at my codebase." Targeted reads keep context lean. |
| Use /status to monitor spend | Builds awareness of what different task types cost so you can make informed trade-offs. |
| Reserve sub-agents for tasks that genuinely benefit | Don't spin up 5 agents when 1 will do. Parallelization has real cost - justify it. |
Once you internalise these numbers, you stop thinking about Claude Code as an expense and start thinking about it as the highest-leverage employee you've ever hired - one that works continuously and gets better as your CLAUDE.md grows.