The Claude Ecosystem
Claude isn't just one thing. It's three distinct tools, each designed for a different way of working. Think of them as three gears — same engine, different speeds.
Each mode consumes tokens differently. Chat is the lightest. Cowork uses more because it plans and executes multi-step tasks. Code uses the most because it reads files, writes code, runs commands, and orchestrates agents — all in tokens.
Claude Chat — The Foundation
This is the Claude most people know. Open claude.ai or the desktop app, type a question, get an answer.
What Chat does well
- Research and brainstorming — ask questions, explore ideas, get explanations
- Content creation — write emails, blog posts, marketing copy
- Code snippets — get code examples (but it can't run them)
- Document analysis — upload PDFs, images, spreadsheets for review
- Web search — Claude can search the internet for current info
What Chat cannot do
- Touch your filesystem (can't create, edit, or move files)
- Run terminal commands
- Execute code
- Interact with external tools or services
Chat features worth knowing
| Feature | What It Does | Tier |
|---|---|---|
| Projects | Organize conversations with shared context docs | Pro+ |
| Artifacts | Interactive code previews, documents, diagrams | All |
| Web Search | Real-time internet searches in conversation | All |
| File Upload | Analyze PDFs, images, CSVs, code files | All |
| Extended Thinking | Deeper reasoning for complex problems | Pro+ |
| Memory | Remembers preferences across conversations | Max |
| Google Workspace | Connect to Google Docs, Drive, Calendar | Pro+ |
Use Projects to give Claude persistent context. Upload your brand guidelines, product docs, or code standards into a project, and every conversation in that project has that context automatically — without you re-explaining every time.
Claude Cowork — The Desktop Agent
Cowork is Claude Code's consumer-friendly sibling. It runs inside the Claude desktop app and can actually do things on your computer — create files, organize folders, process documents — all through a visual interface.
What makes Cowork different
| Chat | Cowork |
|---|---|
| Answers questions | Completes tasks |
| Suggests what to do | Actually does it |
| You copy-paste results | Claude writes files directly |
| One response at a time | Plans multi-step workflows |
| Lightweight usage | Heavier token usage |
Great use cases for Cowork
- File organization — "Sort my Downloads folder by type and date"
- Data processing — "Read this CSV and create a summary report"
- Content creation — "Create a branded PDF playbook from these notes"
- Research compilation — "Research X topic and save findings to a document"
- Batch operations — "Rename all files in this folder following this pattern"
Max plan required ($100-$200/month). macOS only (for now). No memory across sessions. The desktop app must stay open while tasks run. Cowork uses significantly more tokens than Chat because of multi-step task execution.
This is how Damara creates playbooks — Cowork handles the branding, formatting, and content generation, then outputs the files that get pushed to the GitHub Pages repo. Chat would just tell you what to do. Cowork actually does it.
Claude Code — The Terminal Powerhouse
Claude Code is the most powerful way to use Claude. It runs in your terminal and has full access to your development environment — it can read your codebase, write files, run commands, execute tests, commit to git, deploy to production, and orchestrate teams of AI agents.
What Claude Code can do that nothing else can
- Read your entire codebase — understands project structure, dependencies, patterns
- Write and edit files — makes surgical changes or creates new files
- Run terminal commands — git, npm, docker, deploy scripts, anything
- Execute tests — run your test suite and fix failures
- Orchestrate agents — spawn subagents for parallel work
- Connect to external tools — via MCP servers (databases, APIs, Figma, Notion)
- Plan before acting — Plan Mode for thinking before building
The terminal gives Claude Code direct access to your system. No browser sandbox, no file upload limits, no copy-paste. It works WITH your tools — your git, your package manager, your deployment pipeline. That's why it's more powerful than Chat or Cowork for development work.
Getting Started with Claude Code
Installation
First-time setup checklist
- Install Node.js (v18+) if you don't have it
- Install Claude Code via npm
- Run
claudeand authenticate with your Anthropic account - Navigate to a project folder and run
claudefrom there - Create a
CLAUDE.mdin your project root (Section 10)
Always launch Claude Code from your project's root directory. Claude reads the directory structure to understand your project. Launching from ~ (home) means it sees everything — which is slower and less focused.
Every Slash Command Explained
Slash commands are Claude Code's power menu. Type / to see them all.
Essential commands (use these daily)
| Command | What It Does | When to Use It |
|---|---|---|
/help | Shows all available commands | When you forget a command |
/compact | Compresses conversation history | When context gets long, saves tokens |
/cost | Shows token usage and cost for session | Check how much you're spending |
/model | Switch models (sonnet, opus, haiku) | Use haiku for simple tasks, opus for complex |
/clear | Clear conversation history | Start fresh on a new task |
/memory | Edit your CLAUDE.md file | Update project instructions |
Power user commands
| Command | What It Does | When to Use It |
|---|---|---|
/review | Code review of recent changes | Before committing, get a second opinion |
/plan | Enter Plan Mode (read-only exploration) | Research before making changes |
/vim | Toggle Vim keybindings | If you're a Vim user |
/permissions | Manage file access permissions | Control what Claude can read/write |
/context | View current context usage | See how full your context window is |
/doctor | Diagnose installation issues | When something isn't working right |
/agents | Manage custom subagents | Set up specialized AI assistants |
/rewind | Roll back conversation and code | Undo mistakes, try a different approach |
/status | View current session status | Check model, mode, and settings |
/compact is your best friend for long sessions. When your conversation gets long, context fills up and Claude starts losing earlier details. Running /compact compresses the history, freeing up space and reducing token costs on subsequent messages. Use it every 15-20 messages.
Keyboard Shortcuts & Vim Mode
Essential keyboard shortcuts
| Shortcut | Action |
|---|---|
Enter | Send message |
Shift + Enter | New line (without sending) |
Ctrl + C | Cancel current generation |
Ctrl + D | Exit Claude Code |
Ctrl + L | Clear terminal screen |
Esc + Esc | Edit your previous message |
Shift + Tab | Cycle through permission modes |
Ctrl + T | Toggle task list |
Vim Mode
If you're a Vim user, type /vim to enable Vim keybindings in the input area. This gives you:
- Insert mode — type normally (default)
- Normal mode — navigate with h/j/k/l, use w/b for word movement
- Esc switches from INSERT to NORMAL (not cancel)
- Ctrl shortcuts still work in both modes
Custom keybindings
Esc + Esc (double escape) to edit your last message is a game-changer. Made a typo? Want to rephrase? Double-tap Esc instead of retyping the whole thing.
Permission Modes
Claude Code has five permission modes that control how much freedom Claude has. Think of them as safety levels.
| Mode | What Claude Can Do | Best For |
|---|---|---|
| Default | Asks permission for every file edit and command | Learning, unfamiliar codebases |
| Accept Edits | Auto-approves file edits, asks for commands | Day-to-day development |
| Plan Mode | Read-only — can search and read, cannot change anything | Exploring before building |
| Don't Ask | Auto-approves everything | Trusted automation tasks |
| Bypass | No restrictions at all | Isolated environments only (containers) |
Never use "Bypass" mode unless you're in an isolated container or VM. It gives Claude unrestricted access to run any command — including destructive ones. "Don't Ask" is nearly as risky. Stick with Default or Accept Edits for normal work.
Plan Mode — Think Before You Build
Plan Mode is one of Claude Code's most underrated features. It forces Claude to research and think before making any changes.
How it works
What Claude can do in Plan Mode
- Read files — examine your codebase
- Search — find files, search content with Glob and Grep
- List directories — understand project structure
- Research — gather context before proposing changes
What Claude CANNOT do in Plan Mode
- Edit or create files
- Run commands
- Modify anything on your system
The best developers use Plan Mode like a Senior Architect review. Start every significant task in Plan Mode: let Claude explore, understand, and propose. Review the plan. THEN switch to normal mode to execute. This prevents wasted work and token costs from going down the wrong path.
CLAUDE.md — Your Project Brain
CLAUDE.md is a special file that Claude Code reads automatically every time you start a session in that project. It's your project's instruction manual for Claude.
Where to put it
What to put in CLAUDE.md
Think of CLAUDE.md like onboarding a new developer. What would they need to know on day one? Put that in CLAUDE.md. But keep it concise — CLAUDE.md is loaded as context every session, which means every token in it costs you on every message (see Token Management Playbook).
Custom Commands & Skills
Custom slash commands
You can create your own slash commands by adding Markdown files to .claude/commands/ in your project.
Skills (model-invoked)
Skills are more advanced than commands. They live in .claude/skills/ and Claude can invoke them automatically when relevant.
Commands vs Skills
| Feature | Commands | Skills |
|---|---|---|
| Triggered by | You type /command | Claude invokes automatically |
| Complexity | Simple prompt in one file | Can include tool restrictions, agents |
| Location | .claude/commands/ | .claude/skills/ |
| Parameters | $ARGUMENTS placeholder | YAML frontmatter config |
Subagents & Agent Orchestration
This is where Claude Code becomes a team, not just a tool. Subagents are specialized AI assistants that Claude can spawn to handle specific tasks — each running in its own context window.
Built-in subagents
| Agent | Purpose | Tools Available |
|---|---|---|
| Explore | Fast codebase search and analysis | Read-only (Glob, Grep, Read) |
| Plan | Research and context gathering for plans | Read-only |
| General Purpose | Complex multi-step tasks | Full toolset |
Custom subagents
Agent Teams (experimental)
The most advanced orchestration pattern. Claude creates a team lead, spawns independent teammates, and coordinates their work through a shared task list.
Agent orchestration is powerful but token-expensive. Each subagent has its own context window, meaning you're paying for multiple parallel conversations. A 3-agent team can easily use 3-5x the tokens of a single conversation. Use agents for genuinely parallelizable work, not simple sequential tasks.
Limit yourself to 3-4 subagents maximum. More than that and the coordination overhead (also in tokens) outweighs the benefit. Give each agent a clear, specific task with defined scope.
MCP Servers — Supercharging Claude
MCP (Model Context Protocol) servers let Claude Code connect to external tools and services. Think of them as plugins that give Claude new superpowers.
What MCP servers enable
| MCP Server | What Claude Can Do |
|---|---|
| Browser / Playwright | Navigate websites, take screenshots, test UIs |
| Database (Postgres, etc.) | Query databases, analyze data, run migrations |
| Figma | Read designs, implement UI from mockups |
| Notion | Read/write docs, sync project info |
| GitHub | Manage issues, PRs, reviews |
| Sentry | Analyze errors, debug production issues |
| Slack | Send messages, read channels |
Adding an MCP server
Connect Sentry via MCP, and you can say "Look at the top 5 errors in production and fix them." Claude reads the errors from Sentry, finds the code, and patches it. That's a workflow that used to take hours, done in minutes.
Expert Workflows
These are the patterns that separate casual users from power users.
1. The Plan-Execute-Review Loop
2. Model Switching by Task
3. The Compact Ritual
4. CLI-First External Interactions
5. The /rewind Safety Net
Experts treat Claude Code like a senior developer on their team, not a magic box. They give clear context, review output critically, use Plan Mode to align before executing, switch models based on task complexity, and manage their token budget like a project budget.
Free vs Pro vs Max — The Full Breakdown
| Feature | Free | Pro $20/mo | Max $100-200/mo |
|---|---|---|---|
| Claude Chat | Yes | Yes | Yes |
| Claude Code | No | Yes | Yes |
| Claude Cowork | No | No | Yes |
| Messages (per 5 hrs) | ~30-100 | ~45 (standard) | ~225 (5x) / ~900 (20x) |
| Usage Multiplier | 1x | 1x | 5x or 20x vs Pro |
| Extended Thinking | No | Yes | Yes |
| Projects | Limited | Unlimited | Unlimited |
| Memory | No | No | Yes |
| Priority Access | No | No | Yes (peak times) |
| Early Features | No | No | Yes |
| Google Workspace | No | Yes | Yes |
| Remote MCP | No | Yes | Yes |
| Web Search | Yes | Yes | Yes |
| Extra Usage (API overflow) | No | Yes (pay as you go) | Yes (pay as you go) |
Max 5x ($100/mo) vs Max 20x ($200/mo)
| Feature | Max 5x | Max 20x |
|---|---|---|
| Messages per 5-hour window | ~225 | ~900 |
| Usage vs Pro | 5x more | 20x more |
| Claude Code usage | Generous | Virtually unlimited |
| Cowork access | Yes | Yes |
| Best for | Power users, daily devs | All-day coding, agencies, heavy automation |
Extra Usage (the overflow safety net)
When you hit your included limits, Claude doesn't stop — it switches to pay-as-you-go at standard API rates. You opt into this in settings. This means you never get cut off mid-task.
Anthropic gave existing Pro and Max subscribers $50 in free Extra Usage credits to try Opus 4.6 (had to be claimed by Feb 16, 2026). This is the kind of early access perk Max subscribers regularly get.
What Max Gives Boots On The Ground AI
Here's specifically what the Max tier unlocks for Damara and the Boots On The Ground AI workflow:
The Boots playbook creation workflow
What Max enables that Pro doesn't
| Capability | How Boots Uses It |
|---|---|
| Cowork (Max only) | Create branded playbooks, process files, automate content generation without touching a terminal |
| 5-20x usage | Build multiple playbooks in one day without hitting limits |
| Memory | Claude remembers Boots branding (navy #1B2A4A, gold #D4A843), coding preferences, project structure |
| Priority access | No waiting during peak hours — critical when on a deadline |
| Early features | First access to new Claude capabilities (Agent Teams, new models) |
| Extra Usage | Never get cut off mid-playbook — overflow to API pricing seamlessly |
The ROI math
Max isn't just "more messages." It's the difference between using Claude as a chatbot and using Claude as a full-stack development team. For Boots On The Ground AI, it means going from "I need to hire someone" to "I can build this myself" — for a fraction of the cost.
Grade Your Claude Skills
Where do you stand? Be honest. Use this as a roadmap — not a judgment. Every expert started at beginner.
Level 1: Beginner
Level 2: Intermediate
Level 3: Advanced
Level 4: Expert
Let's be real — you're solidly Intermediate heading into Advanced. You use Chat, Cowork, AND Code. You manage a GitHub Pages site. You understand tokens and costs. You're building branded content and pushing to production. The next steps: Plan Mode as a habit, custom commands, and MCP server connections. You're closer to Expert than you think.
Token Usage Across Modes
Not all modes are created equal when it comes to token consumption. Here's what each mode actually costs.
| Mode | Token Usage | Why |
|---|---|---|
| Chat (simple Q&A) | Low (200-1,000 tokens) | Short exchanges, no tool use |
| Chat (with files) | Medium (1,000-10,000) | File content counted as input tokens |
| Cowork (task) | High (5,000-50,000) | Multi-step planning and execution |
| Code (simple edit) | Medium (2,000-8,000) | Reads files, makes changes |
| Code (feature build) | High (10,000-100,000) | Reads codebase, writes multiple files |
| Code (agent teams) | Very High (50,000-500,000+) | Multiple parallel context windows |
Where tokens go in Claude Code
How to minimize token costs
- Use /compact regularly — compresses conversation history (the 28%)
- Keep CLAUDE.md lean — cuts the 12% on every message
- Switch to Haiku for simple tasks — same tokens, much cheaper per token
- Start new sessions for new tasks — don't carry unnecessary history
- Use Plan Mode first — avoids expensive false starts
- Be specific in prompts — vague prompts cause Claude to read more files
- Check /cost periodically — awareness prevents surprises
On Max 20x, you get ~900 messages per 5-hour window. That's roughly 180 messages per hour. Even with heavy Claude Code usage, most developers never hit that limit. And if you do, Extra Usage kicks in at API rates — you're never cut off.