*This is the final Part 3 of our Mastering Claude Code series.*
* [Part 1: Foundations, Setup, and Core Concepts](/mastering-claude-code-part-1-foundations/)
* [Part 2: Workflow Mastery, Plan Mode, and Custom Skills](/mastering-claude-code-part-2-workflow/)
* **Part 3: Advanced Ops, Multi-Agents, and Enterprise Workflows**
## Part 15: Cost Management
Claude Code can consume tokens quickly, especially on complex tasks. Here's how to stay efficient.
### Model Selection
Use **Sonnet 4.6 for ~80% of your work** — writing functions, fixing bugs, adding features, writing tests, explaining code. It's fast and capable.
Switch to **Opus 4.6 for the hardest 20%** — large-scale refactoring, complex architectural decisions, multi-agent workflows, or when you need the 1M token context window.
### Effort Levels
Use `/effort` to set low, medium, or high effort. The default for Opus 4.6 on Max/Team is now medium. Low effort uses fewer tokens and returns faster results — perfect for simple queries and quick fixes.
### Context Management
Keep your CLAUDE.md under 200 lines. Move detailed instructions into skills (they only load when invoked). Use `/compact` when context usage gets high. Put path-specific rules in `.claude/rules/` so they only load when Claude touches matching files.
### Spending Limits
```bash
claude -p "fix failing tests" --max-budget-usd 2.00
```
Hard spending limits prevent runaway costs in automation.
### The /cost Command
Run `/cost` anytime to see your current session's token usage. Track this to build intuition about what's expensive and what's cheap.
## Part 17: The Daily Workflow
Here's a realistic daily workflow for someone using Claude Code productively.
### Morning: Start Fresh
Terminal Sequence
```bash
cd your-project
claude
```
### Understand Context
```
What's changed since yesterday? Show me the recent git log.
```
### Plan Your Feature
```
/plan
I need to add email notifications when a user's subscription is about to expire.
Show me how this should integrate with the existing codebase.
```
Review the plan. Ask questions. Adjust.
### Build It
Switch to auto-accept and let Claude implement the approved plan.
### Test It
```
Run the test suite and fix any failures.
```
### Commit It
```
Commit these changes with an appropriate message.
```
### Start a New Session Per Feature
For each new feature or task, start a new session. This keeps context clean and focused. Use `/compact` if you need to continue in the same session but context is getting heavy.
### Quick Reference
Command Palette
| Action | Command |
|--------|---------|
| Generate CLAUDE.md | `/init` |
| Check installation health | `/doctor` |
| Compress context | `/compact` |
| Change thinking modes | `Shift + Tab` |
| Toggle extended thinking | `Tab` |
| Rewind mistakes | `Esc Esc` |
| Check token usage | `/cost` |
| Switch model | `/model` |
| Set effort level | `/effort` |
## Part 19: Claude Code for Non-Coders
Here's the thing nobody tells you: Claude Code is increasingly useful even if you don't write code for a living.
### Organizing Files
Point Claude Code at a folder of messy files and ask it to organize, rename, or categorize them. It can analyze file contents and create a sensible structure.
### Processing Documents
Have a folder of PDFs, CSVs, or text files? Claude Code can read, analyze, summarize, and extract data from them — then generate reports.
### Building Quick Tools
Describe a tool you need in plain language ("I need a script that converts all images in this folder to thumbnails") and Claude Code will build it, test it, and leave it ready to run.
### Automating Repetitive Tasks
Anything you do repeatedly on your computer that involves files — renaming, reformatting, extracting, converting — Claude Code can probably automate it.
### The Sandbox Approach
If you're nervous about Claude Code touching your files, create a dedicated folder (literally called "Claude Code Test" if you want) and only run Claude Code from there. It can only see and modify files within its working directory.
## Part 21: Claude Certified Architect — The Certification
Anthropic has released the **[Claude Certified Architect – Foundations](https://anthropic.skilljar.com/claude-certified-architect-foundations-access-request)** certification for practitioners who design and implement production applications with Claude. It covers five domains:
1. **Agentic Architecture & Orchestration** (27%) — building agentic loops, multi-agent systems, coordinator-subagent patterns
2. **Tool Design & MCP Integration** (18%) — designing effective tool interfaces, structured error handling, MCP server configuration
3. **Claude Code Configuration & Workflows** (20%) — CLAUDE.md hierarchies, custom skills, plan mode, CI/CD integration
4. **Prompt Engineering & Structured Output** (20%) — few-shot prompting, JSON schema enforcement, validation-retry loops
5. **Context Management & Reliability** (15%) — managing long conversations, escalation patterns, information provenance
The exam is scenario-based with multiple choice questions. Minimum passing score is 720 out of 1,000. If you're building production systems with Claude, this is worth pursuing.
Free learning resources are available through Anthropic Academy, including a dedicated "Claude Code in Action" course.
paths:
- "src/api/**/*"
paths:
- "**/*.test.*"
- "**/*.spec.*"
## Wrapping Up
Claude Code isn't magic. It's a tool — a remarkably powerful one — that gets better the more context you give it and the more intentionally you use it.
Start small. Install it. Run `/init` in a project. Ask it to explain your codebase. Make a small change. Get comfortable with the workflow.
Then gradually level up: add a CLAUDE.md, create a custom skill, try Plan Mode on a bigger task, connect an MCP server, set up a CI/CD integration.
The people getting the most out of Claude Code aren't necessarily the best programmers. They're the ones who've learned to communicate clearly, give good context, and work iteratively.
And honestly? That's a skill anyone can develop.
---