{"slug": "claude-code-as-a-daily-driver-claude-md-skills-subagents-plugins-and-mcps", "title": "Claude Code as a Daily Driver: Claude.md, Skills, Subagents, Plugins, and MCPs", "summary": "Anthropic's Claude Code tool offers advanced features including a layered configuration system, custom commands, subagents, and plugins that transform it from a basic chatbot into a programmable autonomous agent. The `.claude/` directory provides project and global configuration scopes with files for instructions, settings, skills, commands, and agents that compound in value over time. Daily drivers leverage patterns like plan mode for exploration before coding, delegating tasks rather than pair-programming, and using `CLAUDE.md` to document mistakes so the tool learns from its own failures.", "body_md": "Claude Code is one of those tools where the difference between a casual user and someone who has internalized it is enormous. The casual user types prompts, accepts suggestions, and treats it like a fancier autocomplete. The daily driver uses it like a programmable agent with memory, custom commands, parallel sessions, and a project setup that compounds over time. This guide is for the second kind of person, assuming you already know what `claude`\n\ndoes when you type it in a terminal.\n\n## 1. Claude Code Beyond the Basics[#](#1-claude-code-beyond-the-basics)\n\nOnce you stop thinking of Claude Code as a prompt-and-wait chatbot and start treating it as an autonomous agent that needs guardrails, your workflow shifts. The single most important principle from Boris Cherny and the Anthropic team: **give Claude a way to verify its own work**. Without that, you are the only feedback loop. With it, Claude iterates until things actually work, and Boris says this alone gives a 2-3x quality improvement.\n\nA few patterns that change how you operate day to day:\n\n**Explore, then plan, then code.** Plan mode (`Shift+Tab`\n\ntwice) puts Claude into read-only exploration. Read files, trace flows, understand the data model. Then get a plan. Then execute. Skip planning for small fixes; use it for anything touching more than one file.\n\n**Use plan mode like a design document.** Have one Claude write the plan, then spin up a second Claude in a fresh session to review it as a staff engineer, with no context bias, so it actually catches gaps. If implementation goes sideways, go back to plan mode and re-plan with verification steps included.\n\n**Reference, do not describe.** Instead of “look at the auth module”, type `@src/auth/login.py`\n\n. Instead of pasting an error, pipe it: `cat error.log | claude`\n\n. Exact context beats approximate description every time.\n\n**Delegate, do not pair-program.** Cat Wu (Claude Code team): “The model performs best if you treat it like an engineer you’re delegating to, not a pair programmer you’re guiding line by line.” Write a crisp brief upfront, then let it run.\n\n:Press`Ctrl+G`\n\nto open Claude’s plan in your editor and tweak it before Claude proceeds. The plan is just text, so shape it before it becomes code.\n\n:When Claude makes a mistake, end your prompt with “Update CLAUDE.md so you do not repeat this.” Boris calls Claude “eerily good at writing rules for itself” from its own failures. This habit compounds more than any other in this guide.\n\n## 2. The .claude Directory, Properly Understood[#](#2-the-claude-directory-properly-understood)\n\nMost people open `.claude/`\n\nonce, see `CLAUDE.md`\n\n, and never look further. It is actually a layered configuration system.\n\nTwo scopes: **Project scope** lives in `.claude/`\n\ninside your repo, committed to git so your team shares it. **Global scope** lives in `~/.claude/`\n\nand applies across every project on your machine.\n\nMental model: project files describe the project, global files describe you.\n\n| File | Scope | Commit | What it does |\n|---|---|---|---|\n`CLAUDE.md` | Project and global | Yes | Instructions loaded every session |\n`CLAUDE.local.md` | Project only | No, gitignore it | Your private project notes |\n`settings.json` | Project and global | Yes | Permissions, hooks, env vars, model defaults |\n`settings.local.json` | Project only | No | Personal overrides, auto-gitignored |\n`.mcp.json` | Project only | Yes | Team-shared MCP servers |\n`skills/<name>/SKILL.md` | Project and global | Yes | Reusable prompts invoked with `/name` |\n`commands/*.md` | Project and global | Yes | Single-file slash commands |\n`agents/*.md` | Project and global | Yes | Subagent definitions |\n`rules/*.md` | Project and global | Yes | Topic-scoped instructions, optionally path-gated |\n\nA typical layout:\n\n```\n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14\n```\n\n | \n\n```\nmy-repo/\n├── .claude/\n│   ├── settings.json\n│   ├── agents/\n│   │   ├── pr-review.md\n│   │   └── test-writer.md\n│   ├── skills/\n│   │   └── api-conventions/SKILL.md\n│   └── rules/\n│       ├── frontend.md        # path-gated to src/frontend/\n│       └── migrations.md      # path-gated to db/migrations/\n├── CLAUDE.md                  # checked in, team-shared\n├── CLAUDE.local.md            # gitignored, personal\n└── .mcp.json                  # team-shared MCP servers\n```\n\n |\n\nA few things easy to miss:\n\n`CLAUDE.md`\n\n**files cascade.** In a monorepo, both `root/CLAUDE.md`\n\nand `root/services/billing/CLAUDE.md`\n\nload when you work in the billing service. Powerful for codebases with different conventions per folder.\n\n`rules/*.md`\n\n**is path-gated.** Guidance specific to your migrations folder does not belong in `CLAUDE.md`\n\nbloating every session; it belongs in `.claude/rules/migrations.md`\n\nwith a glob.\n\n**Skills over commands.** `.claude/commands/*.md`\n\nand `.claude/skills/<name>/SKILL.md`\n\nboth create slash commands, but skills support supporting files, `disable-model-invocation`\n\n, allowed tools, and agent overrides. New work should go in `skills/`\n\n.\n\n:Run`claude project purge ~/path/to/repo --dry-run`\n\nto see exactly what local state Claude holds for a project, handy before handing off a laptop.\n\n## 3. CLAUDE.md, The Way Boris Writes It[#](#3-claudemd-the-way-boris-writes-it)\n\n`CLAUDE.md`\n\nis loaded at the start of every session. Get it wrong and Claude repeats the same mistakes. Get it right and the same prompt produces dramatically better output.\n\nBoris is direct about two things that matter more than the rest:\n\n**Keep it short.** Long files bury important rules. For every line, ask: “Would removing this cause Claude to make a mistake?” If not, cut it.\n\n**Let Claude write rules for itself.** Any time Claude does something wrong, tell it: “Update CLAUDE.md so you do not repeat this.” Claude is surprisingly good at distilling its own mistakes into precise rules. Do this for a few weeks and the file becomes a curated list of every gotcha your project has.\n\n### 3.1 The Real CLAUDE.md From the Claude Code Team[#](#31-the-real-claudemd-from-the-claude-code-team)\n\nBoris has shared the actual `CLAUDE.md`\n\nthe Claude Code team checks into their own repo. The whole team contributes mulle times a week:\n\n```\n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n```\n\n | \n\n```\n# Development Workflow\n\n**Always use `bun`, not `npm`.**\n\n# 1. Make changes\n\n# 2. Typecheck (fast)\n\nbun run typecheck\n\n# 3. Run tests\n\nbun run test -- -t \"test name\" # Single suite\nbun run test:file -- \"glob\" # Specific files\n\n# 4. Lint before committing\n\nbun run lint:file -- \"file1.ts\"\nbun run lint\n\n# 5. Before creating PR\n\nbun run lint:claude && bun run test\n```\n\n |\n\nThat is the entire file. Build commands Claude cannot guess, the exact order to run things, single-test invocations, the pre-PR ritual. No style preferences. No codebase tours. No platitudes.\n\nBoris also uses `@claude`\n\nin PR comments to have Claude commit a rule directly:\n\n```\n1\n2\n```\n\n | \n\n```\nnit: use a string literal, not a ts enum\n@claude add to CLAUDE.md to never use enums, always prefer literal unions\n```\n\n |\n\nHe calls this “Compounding Engineering,” where every PR review becomes a CLAUDE.md improvement.\n\nA fleshed-out template following the same philosophy:\n\n```\n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n```\n\n | \n\n```\n# Code style\n\n- Use ES modules (import/export), not CommonJS (require)\n\n# Workflow\n\n- Always use `bun`, not `npm`\n- Run `bun run typecheck` before claiming done\n- Never push to main directly. Always open a PR.\n\n# Architecture\n\n- All API routes go through src/api/middleware/auth.ts\n- New database queries go in src/db/queries/. No inline raw SQL.\n\n# Gotchas\n\n- `User` and `UserRecord` are distinct types. UserRecord is the DB row, User is the runtime object.\n- `formatCurrency` assumes USD. For international use `formatCurrencyByLocale`.\n```\n\n |\n\nThe “Gotchas” section is the magic. Every entry is a mistake Claude made, captured the moment it happened.\n\n**What does not belong in CLAUDE.md:** standard language conventions, file-by-file codebase descriptions, long tutorials, API docs, anything that changes frequently.\n\n:Words like`IMPORTANT`\n\nor`YOU MUST`\n\nimprove adherence. Use them sparingly so they carry weight.\n\nYou can import other files using `@path`\n\nsyntax to keep `CLAUDE.md`\n\nshort while pulling in details:\n\n```\n1\n2\n```\n\n | \n\n```\nSee @README.md for project overview and @package.json for scripts.\n@~/.claude/my-preferences.md\n```\n\n |\n\n### 3.2 Popular CLAUDE.md Files Worth Studying[#](#32-popular-claudemd-files-worth-studying)\n\n: conventions for how skills should be written and tested[mattpocock/skills CLAUDE.md](https://github.com/mattpocock/skills/blob/main/CLAUDE.md): Anthropic’s own repo, treated the same as internal tools[anthropics/claude-code-action](https://github.com/anthropics/claude-code-action): links to dozens of public[awesome-claude-code](https://github.com/hesreallyhim/awesome-claude-code)`CLAUDE.md`\n\nfiles across language ecosystems: community-curated examples organized by stack[claudelog.com](https://claudelog.com/)\n\n## 4. CLAUDE.local.md as a Daily Driver[#](#4-claudelocalmd-as-a-daily-driver)\n\n`CLAUDE.local.md`\n\nlives alongside `CLAUDE.md`\n\n, gets loaded the same way, but never leaves your machine. Add it to `.gitignore`\n\n.\n\nThe way I use it: after every PR I open, reviewers leave comments. Instead of trying to remember them, I dump them into `CLAUDE.local.md`\n\nthe moment I see them. Over time it becomes a personalized rule file for exactly the feedback I get most often.\n\n```\n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n```\n\n | \n\n```\n# Personal review notes (private)\n\n# From PR feedback\n\n- New SQS consumers need a DLQ and alarms in the same PR\n- Use `Optional<T>` over null returns\n- Tests for new endpoints must include the auth-failure case\n- Prefer named tuples over plain dicts for return types with 3+ fields\n\n# My own quirks to correct\n\n- Stop using `console.log`; use the project logger instead\n- Always update the OpenAPI spec when adding endpoints\n```\n\n |\n\nLoaded every session, Claude already knows to include auth-failure tests and update the OpenAPI spec without me mentioning it. Nitpick comments on my PRs dropped noticeably within a couple of weeks.\n\n:Keep two sections clearly separated: project-specific feedback and personal habits to correct. Mixing them makes the file harder to prune later.\n\n:Prune after a few weeks. Things that have become muscle memory can go. The file should capture what is still learning, not what you already do automatically.\n\n## 5. Skills, In Depth[#](#5-skills-in-depth)\n\nSkills let Claude Code go from “an agent that can do anything” to “an agent that does specific things really well for your project.” They are the unit of reusable expertise.\n\n### 5.1 What Skills Actually Are[#](#51-what-skills-actually-are)\n\nA skill is a folder under `.claude/skills/<name>/`\n\n(project) or `~/.claude/skills/<name>/`\n\n(global) containing a `SKILL.md`\n\nwith frontmatter and instructions. The folder name becomes the slash command.\n\nThe simplest possible skill:\n\n```\n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n```\n\n | \n\n```\n---\ndescription: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed, wants a commit message, or asks to review their diff.\n---\n\n## Current changes\n\n!`git diff HEAD`\n\n## Instructions\n\nSummarize the changes in two or three bullet points, then list any risks: missing error handling, hardcoded values, tests that need updating.\n```\n\n |\n\nSave to `~/.claude/skills/summarize-changes/SKILL.md`\n\nand `/summarize-changes`\n\nis available in every session.\n\n**Three things that make Skills powerful:**\n\n**Progressive disclosure.** Claude loads only frontmatter descriptions at session start (~100 tokens each). Full`SKILL.md`\n\nand helper files load only when the skill is actually needed.**Skills are folders, not files.** Bundle templates, reference docs, scripts, config.`SKILL.md`\n\nis just the entry point.**Inline shell.** Lines starting with`!`\n\nrun a command and inject the output at invocation time.\n\nFrontmatter supports useful extras:\n\n```\n1\n2\n3\n4\n5\n6\n7\n```\n\n | \n\n```\n---\nname: my-skill\ndescription: When to use this skill\ndisable-model-invocation: true # only runs when user explicitly types /my-skill\nallowed-tools: Read, Grep, Bash\nagent: read-only\n---\n```\n\n |\n\n:Use`disable-model-invocation: true`\n\nfor skills with side effects. You want`/ship`\n\nto deploy only when explicitly typed, not when Claude decides it is relevant.\n\n### 5.2 Writing a Real Skill: Go API Conventions[#](#52-writing-a-real-skill-go-api-conventions)\n\nA complete skill for a Go service team, covering conventions, gotchas, and scaffolding for a new HTTP handler:\n\n```\n1\n2\n3\n4\n5\n6\n```\n\n | \n\n```\n.claude/skills/go-handler/\n├── SKILL.md\n├── templates/\n│   └── handler.go.tmpl\n└── examples/\n    └── healthz.go\n```\n\n |\n\n```\n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n```\n\n | \n\n```\n---\ndescription: Scaffolds a new HTTP handler in our Go service following team conventions for routing, validation, error handling, and tests. Use when the user asks to add a new endpoint, a new handler, or extend an existing route group.\n---\n\n# Go HTTP Handler Skill\n\n## Stack\n\n- Go 1.22 with chi router\n- sqlc for typed queries, never write raw SQL strings in handlers\n- zap for structured logging, never fmt.Println\n- testify for assertions, table-driven tests preferred\n\n## Gotchas\n\n- `chi.URLParam` returns `\"\"` for missing params, not an error. Always check.\n- Our `httperr.Wrap` does not log. Log separately with `h.log.Error` before returning.\n- Auth middleware injects via `context.Value(authkey.User)`. Type-assert to `*models.User`.\n- sqlc nullable strings use `pgtype.Text`. Check `.Valid` before calling `.String`.\n- Tests must use `httptest.NewRecorder` and `httptest.NewRequest`. No real server.\n```\n\n |\n\nA skill like this lets a new developer add a fully conventional endpoint without reading the entire codebase first.\n\n### 5.3 Popular Skills Worth Installing[#](#53-popular-skills-worth-installing)\n\n** mattpocock/skills**, the most popular skills repo (~100k stars). Standouts:\n\n`/grill-me`\n\n: interviews you about a plan before any code gets written`/tdd`\n\n: enforces red-green-refactor strictly`/diagnose`\n\n: disciplined debugging, reproduce, minimize, hypothesize, fix, regression test\n\nInstall: `npx skills@latest add mattpocock/skills`\n\n** Jeffallan/claude-skills** ships 66 language-specific profiles:\n\n`go-pro`\n\n, `python-pro`\n\n, `java-architect`\n\n, `typescript-pro`\n\n, `rust-engineer`\n\n, `sql-pro`\n\n, and more. Compose them; a Next.js task pulls in `nextjs-developer`\n\nand `typescript-pro`\n\ntogether.**Anthropic’s official skills:**\n\n`/code-review`\n\n: four parallel agents audit the diff, confidence-scored findings only`/simplify`\n\n: reviews recent code for reuse and efficiency`/batch`\n\n: fans out a migration to dozens of parallel agents, each in its own worktree`/webapp-testing`\n\n: gives Claude Playwright control to test your local web app\n\n:If you do something more than once a day, turn it into a skill. Anything you repeat is a skill waiting to be written.\n\n:Check skills into git. They become institutional knowledge, and new engineers clone the repo and get the team’s accumulated practices for free.\n\n## 6. Building Custom Subagents[#](#6-building-custom-subagents)\n\nA subagent runs in its own context window with its own tool permissions and reports back a summary. It can read fifty files without filling up your main session. That is the entire value proposition.\n\nA subagent is a markdown file under `.claude/agents/`\n\n(project) or `~/.claude/agents/`\n\n(global) with a frontmatter block declaring name, description, tools, and model.\n\n### 6.1 Walking Through a /pr-review Agent[#](#61-walking-through-a-pr-review-agent)\n\n```\n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n```\n\n | \n\n```\n---\nname: pr-review\ndescription: Reviews the current branch diff against main, looking for bugs, security issues, missed edge cases, and project-convention violations. Use proactively before opening a PR.\ntools: Read, Grep, Glob, Bash\nmodel: opus\n---\n\nYou are a senior staff engineer reviewing a pull request. Thorough, direct, goal is to catch issues before human reviewers do.\n\n## Process\n\n1. Run `git diff main...HEAD`\n2. Run `git log main..HEAD --oneline`\n3. Read full files, not just diff context\n4. Cross-check against CLAUDE.md, CLAUDE.local.md, and .claude/rules/\n\n## Flag\n\n- Correctness bugs: off-by-one, null handling, error paths, race conditions\n- Security: injection risks, missing auth checks, secrets in code\n- Missing tests for new logic\n- N+1 queries\n- Convention violations from CLAUDE.md or rules/\n\n## Do NOT flag\n\n- Style preferences not in project rules\n- Refactoring suggestions for working code\n- Anything outside this diff\n\n## Output\n\nGroup by severity (Critical / High / Medium / Low). File + line + issue + suggested fix.\nEnd with a verdict: **SHIP**, **FIX FIRST**, or **REWORK**.\n```\n\n |\n\nRun it by saying `Have the pr-review agent look at my current branch.`\n\nThe subagent handles everything in its own context, your main session stays clean.\n\nKey design choices: `tools`\n\nis read-only, because a reviewer that modifies code gets biased toward defending its own edits. `model: opus`\n\nfor high-stakes review. The “Do NOT flag” section keeps signal-to-noise high.\n\n### 6.2 Popular Subagents Worth Stealing[#](#62-popular-subagents-worth-stealing)\n\nThe Claude Code team checks in: `build-validator`\n\n, `code-architect`\n\n, `code-simplifier`\n\n, `oncall-guide`\n\n, `verify-app`\n\n.\n\nCommunity patterns worth adopting:\n\n| Agent | What it does |\n|---|---|\n`security-reviewer` | injection, auth, secrets, insecure deserialization |\n`test-writer` | generates tests, pairs with code-reviewer in a loop |\n`debugger` | traces failing tests to root causes |\n`performance-auditor` | profiles flows and queries |\n`migration-writer` | generates DB migrations matching project conventions |\n`release-notes-writer` | changelogs from commit history |\n\nCurated repos: [VoltAgent/awesome-claude-code-subagents](https://github.com/VoltAgent/awesome-claude-code-subagents) (100+ agents) and [hesreallyhim/a-list-of-claude-code-agents](https://github.com/hesreallyhim/a-list-of-claude-code-agents).\n\n:Chain agents: Session A implements, then call`Use the code-reviewer subagent to check the work.`\n\nThe reviewer evaluates in a fresh context with no implementation bias.\n\n:Add`isolation: worktree`\n\nto frontmatter to run the subagent in its own git worktree, especially powerful when fanning out a migration across dozens of parallel agents.\n\n## 7. Plugins and the Marketplace[#](#7-plugins-and-the-marketplace)\n\nPlugins bundle skills, hooks, subagents, and MCP servers into a single installable unit. Run `/plugin`\n\nto open the marketplace browser. Add community marketplaces with `/plugin marketplace add owner/repo`\n\n.\n\n**Day-one installs:**\n\n** /code-review** runs four parallel agents: two audit for CLAUDE.md compliance, one scans for bugs, one analyzes git blame for context. Confidence-scored, high signal-to-noise.\n\n** /feature-dev** is the most popular skill on the official marketplace. Turns a feature brief into working code through seven phases: requirements → exploration → architecture → implementation → testing → review → docs.\n\n**Language server plugin** provides precise symbol navigation and automatic diagnostics after every edit. The team consistently calls this the single highest-impact plugin you can install.\n\n** /security-guidance** is Anthropic’s official security skill, surfacing concerns before they ship.\n\nPlugin categories worth knowing (1,000+ plugins across 75+ marketplaces as of mid-2026):\n\n- Git workflow, code intelligence (LSP), documentation generators, testing, browser automation (Playwright), design system (Figma), observability (Sentry, Datadog)\n\n:A team-shared`.mcp.json`\n\nplus a few well-chosen plugins gets a new engineer productive within minutes of cloning the repo. Treat plugin choices as part of your onboarding story.\n\n## 8. Underused Claude Code Commands[#](#8-underused-claude-code-commands)\n\nMost users learn `/clear`\n\n, `/compact`\n\n, and `/init`\n\nand stop. A handful of the rest quietly do more for productivity than anything else.\n\n| Command | What it does |\n|---|---|\n`/insights` | Analyzes your usage patterns; run once a month |\n`/compact <hint>` | Compresses session; hint controls what survives |\n`/copy` | Copies last response; interactive picker for code blocks |\n`/rewind` | Undo for your whole session, restoring code, conversation, or both |\n`/btw` | Side question that never enters conversation history |\n`/context` | Visualizes context usage |\n`/export <file>` | Dumps conversation to file |\n`/branch` | Forks your session to try something risky |\n`/batch` | Fans work out to parallel agents across worktrees |\n`/loop <interval>` | Schedules Claude to run on repeat, up to 3 days |\n`/schedule` | Cloud version of `/loop` , works even when your laptop is closed |\n`/teleport` | Moves a session between terminal and web |\n`/focus` | Hides intermediate tool calls, shows only final result |\n`/voice` | Voice input; Boris says he codes mostly by speaking |\n`--bare` | Up to 10x faster startup for non-interactive `claude -p` usage |\n\n** /compact vs /clear:** genuinely new task =\n\n`/clear`\n\nwith a fresh hand-written brief. Related task where you still need context = `/compact`\n\nwith a hint. `/compact`\n\nis a lossy LLM summary; `/clear`\n\nis your brief. That distinction matters.** /rewind** creates a checkpoint for every prompt, and those persist across sessions. When Claude goes down a wrong path, do not type “that did not work, try X,” as that pollutes context. Rewind and re-prompt with what you learned.\n\n:Use`!`\n\nas a shell escape.`!git status`\n\nor`!npm test`\n\nruns immediately with output landing in context.\n\n:Set`CLAUDE_CODE_AUTO_COMPACT_WINDOW=400000`\n\n. Context rot kicks in around 300-400k tokens on the 1M model, so force earlier compaction to stay sharp.\n\n**Fan-out pattern:** generate a task list, then loop:\n\n```\n1\n2\n3\n4\n5\n```\n\n | \n\n```\nfor file in $(cat files.txt); do\n  claude -p \"Migrate $file from React to Vue. Return OK or FAIL.\" \\\n    --allowedTools \"Edit,Bash(git commit *)\" \\\n    --bare\ndone\n```\n\n |\n\nTest on three files. Fix the prompt. Then run on two thousand.\n\n### 8.1 /goal, the Ralph Loop Built In[#](#81-goal-the-ralph-loop-built-in)\n\n`/goal`\n\nsets a completion condition. Claude keeps working until the condition is true. Every time it tries to stop, it checks the condition against the transcript.\n\n```\n1\n```\n\n | \n\n```\n/goal all tests in test/auth pass and the lint step is clean\n```\n\n |\n\nReal examples:\n\n```\n1\n2\n3\n4\n```\n\n | \n\n```\n/goal all integration tests in tests/api pass without flaking 3 runs in a row\n/goal the OpenAPI spec validates and matches the actual response shapes\n/goal docker compose up runs cleanly and the healthcheck endpoint returns 200\n/goal coverage on src/billing/ is above 80% and all new tests are not placeholders\n```\n\n |\n\nPick a verifiable, deterministic condition, tied to a test command, CLI exit code, or file state. Vague conditions like “the code is good” do not work.\n\nCompanions that pair well:\n\n`/loop`\n\n: repeat at an interval, burn down a backlog`/schedule`\n\n: run on a cadence in the cloud- A\n`Stop`\n\nhook: gate on your own test suite or CI endpoint **Auto mode**: removes permission prompts so long goals do not stall\n\n:Combine`/goal`\n\n+ auto mode +`/focus`\n\n. Write a crisp brief, set the goal, walk away. Come back to a finished PR. This is the workflow Boris and Cat Wu push for Opus 4.7.\n\n## 9. MCPs as Power Tools[#](#9-mcps-as-power-tools)\n\nMCP (Model Context Protocol) turns Claude Code from a coding agent into a system-aware coding agent. An MCP server exposes external tools like a database, a design tool, your error tracker, or your notes to Claude in a standardized way.\n\nWithout MCP, Claude reads files and runs commands. With MCP, Claude reads your Linear tickets, queries your Postgres, pulls up a Figma component, fetches live Sentry stack traces, or reads your Obsidian vault, all without leaving the terminal.\n\n**The go-to MCPs for engineering work:**\n\n| MCP | What it unlocks |\n|---|---|\n| GitHub | Repo management, PRs, issues, code search |\n| Context7 | Live, up-to-date library docs; append `use context7` to any prompt |\n| Sentry | Real error context, stack traces, breadcrumbs |\n| Linear | Read/create tickets, update status |\n| Playwright | Browser automation via accessibility snapshots |\n| Figma | Live design tree: auto-layout, spacing tokens, component refs |\n| Postgres / Supabase | Query your dev DB directly |\n| Slack | Read threads, summarize discussions, draft responses |\n\nLocal servers use stdio, vendor-hosted use HTTP with OAuth:\n\n```\n1\n```\n\n | \n\n```\nclaude mcp add --transport http sentry https://mcp.sentry.dev/mcp\n```\n\n |\n\nTeam-shared MCPs go in `.mcp.json`\n\nat the project root. Personal MCPs go in `~/.claude.json`\n\n.\n\n### 9.1 A Real Obsidian Workflow[#](#91-a-real-obsidian-workflow)\n\nThe Obsidian + Claude Code pairing becomes genuinely powerful when you use it as a three-tier memory architecture, not just “Claude can read my vault.”\n\n**Setup:** Install `obsidian-claude-code-mcp`\n\nin Obsidian (exposes the vault on a local WebSocket, port 22360). Claude Code auto-discovers it. Add a `CLAUDE.md`\n\nto your vault explaining the folder structure.\n\n**Folder structure:**\n\n```\n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n```\n\n | \n\n```\nvault/\n├── 00-Inbox/         # raw capture\n├── 10-Daily/         # one note per day\n├── 20-Projects/      # active project notes\n│   └── billing-v2/\n│       ├── README.md      # goal, status, open questions\n│       ├── decisions/     # ADRs\n│       └── sessions/      # one log per Claude session\n├── 30-Decisions/     # cross-project ADRs\n├── 40-Atoms/         # reusable knowledge, linked\n└── 90-Archive/\n```\n\n |\n\n**The three tiers:**\n\n**Hot storage: daily session log.** Every Claude session writes a timestamped log to `10-Daily/<today>.md`\n\n. A `Stop`\n\nhook can do this automatically: when the agent finishes, it appends a structured summary.\n\n**Warm storage: project notes.** Each project has a folder under `20-Projects/`\n\n. Before any new session, Claude reads the project README and last 2-3 session logs to rebuild context. Two weeks of context in 30 seconds.\n\n**Cold storage: decisions and atoms.** Architectural decisions get promoted into `30-Decisions/`\n\nas ADRs. Reusable knowledge gets distilled into `40-Atoms/`\n\nand linked via wikilinks across all projects.\n\n**Daily workflows:**\n\n`What is in my inbox? Summarize and suggest where each item belongs.`\n\n`Check 30-Decisions/ for anything related to retry policies.`\n\n`Read the last 3 session logs for billing-v2. Tell me where I left off.`\n\n:Resist installing every MCP. Each one expands the tool list Claude reasons over, and bloated tool lists hurt decision quality. Starter set: GitHub, Context7, plus one or two domain-specific.\n\n:Run`/mcp`\n\ninside Claude Code to list every active server and its connection status. First place to check when something is not working.\n\n## 10. Optimizing Your Daily Workflow[#](#10-optimizing-your-daily-workflow)\n\n**Morning.** Open Claude Code in the project. Skim what subagents and scheduled jobs did overnight. Run `/insights`\n\nonce a week.\n\n**New feature.** Plan mode → edit plan with `Ctrl+G`\n\n→ implement → invoke `/pr-review`\n\nsubagent or spin up a fresh Claude session to review.\n\n**Bug.** Reproduce first. Pipe the error: `cat error.log | claude`\n\n. Ask Claude to write a failing test that reproduces it. Only then ask it to fix. The test prevents the fix from being a guess.\n\n**Migrations or mass changes.** Use `/batch`\n\n, which interviews you about the change, then fans out to parallel agents, each in its own worktree, each testing and creating a PR.\n\n**Unfamiliar code.** Use a subagent: “Use a subagent to investigate how our auth handles token refresh.” It reads dozens of files in its own context and reports back a summary. Your main session stays clean.\n\n**Parallel sessions.** Boris and the team call this the single biggest productivity unlock: three to five git worktrees, each running its own Claude session. Use the agent view (`claude agents`\n\n) as a control plane.\n\n**Writer/Reviewer pattern.** Session A implements. Session B reviews in a fresh context. Copy the review back, fix, repeat.\n\n**Compact at milestones.** After finishing a logical chunk: `/compact Preserve the decisions made, files changed, and test commands.`\n\n:Never let Claude claim success without evidence, whether that is tests, screenshots, or real command output. The trust-then-verify gap is the single biggest source of bad output.\n\n## 11. s From the Anthropic Team[#](#11-s-from-the-anthropic-team)\n\nCollected from Boris, Cat Wu, Thariq, and the broader team. These are the patterns that actually change how they work:\n\n**“Give Claude a way to verify its output. Once you do that, Claude will iterate until the result is great.”** Boris’s single most-repeated .\n\n**Use Opus with high or xhigh effort for almost everything.** The smaller model that needs more correction is often slower overall, which is Boris’s reasoning for defaulting to Opus.\n\n**Run 3-5 sessions in parallel.** Worktrees over checkouts. Use `claude --worktree`\n\nor the Desktop app. The agent view ties them together.\n\n**Maintain a notes directory per project, updated after every PR.** Tell Claude to keep notes in a directory, point `CLAUDE.md`\n\nat it. The codebase compounds in self-knowledge.\n\n**Build a /techdebt slash command.** Run it at the end of every session to find and kill duplicated code.\n\n**The team’s CLAUDE.md is shared and edited mulle times a week.** Anytime someone sees Claude do something incorrectly, they add a rule. Treat it as a living document.\n\n** Esc twice opens rewind.** Combined with checkpoints: try risky things, find out they failed, rewind cleanly.\n\n**For UI changes, set up Playwright MCP.** Boris uses the Chrome extension every time he works on web code, where Claude opens a browser, clicks around, and verifies.\n\n**Install a language server plugin.** Type errors and unused imports caught after every edit. Highest-impact plugin you can install.\n\n**Use /voice for prompting.** You speak 3x faster than you type, and prompts get way more detailed as a result.\n\n**Auto mode + /focus + /goal.** Crisp brief, set the goal, walk away. Come back to a finished PR.\n\n**Use Ctrl+G to edit Claude’s plan in your editor before implementation.** Faster than typing corrections in the chat.\n\n**Ask Claude to draw ASCII diagrams of new protocols and codebases.** Boris’s for understanding unfamiliar code quickly.\n\n## 12. Resources[#](#12-resources)\n\n**Official docs**\n\n[Claude Code documentation](https://code.claude.com/docs/en/overview)[Explore the .claude directory](https://code.claude.com/docs/en/claude-directory)[Best practices for Claude Code](https://code.claude.com/docs/en/best-practices)[Memory (CLAUDE.md, rules, auto memory)](https://code.claude.com/docs/en/memory)[Skills](https://code.claude.com/docs/en/skills)·[Subagents](https://code.claude.com/docs/en/sub-agents)·[Plugins](https://code.claude.com/docs/en/plugins)·[MCP](https://code.claude.com/docs/en/mcp)·[Hooks](https://code.claude.com/docs/en/hooks)\n\n**Boris and the team**\n\n[How Boris Uses Claude Code](https://howborisusesclaudecode.com/): 89+ s from the creator, sourced from his X threads[Anthropic blog: Best practices for Opus 4.7 with Claude Code](https://claude.com/blog/best-practices-for-using-claude-opus-4-7-with-claude-code)[shanraisshan/claude-code-best-practice](https://github.com/shanraisshan/claude-code-best-practice)\n\n**Skills**\n\n[mattpocock/skills](https://github.com/mattpocock/skills): “Skills for Real Engineers”[Jeffallan/claude-skills](https://github.com/Jeffallan/claude-skills): 66 language-specific skills[addyosmani/web-quality-skills](https://github.com/addyosmani/web-quality-skills): web performance and quality[Anthropic skills cookbook](https://platform.claude.com/cookbook/skills-notebooks-01-skills-introduction)\n\n**Subagents**\n\n[VoltAgent/awesome-claude-code-subagents](https://github.com/VoltAgent/awesome-claude-code-subagents): 100+ organized by category[hesreallyhim/a-list-of-claude-code-agents](https://github.com/hesreallyhim/a-list-of-claude-code-agents)\n\n**Plugins and marketplaces**\n\n[Chat2AnyLLM/awesome-claude-plugins](https://github.com/Chat2AnyLLM/awesome-claude-plugins): 1000+ plugins across 75+ marketplaces[claudemarketplaces.com](https://claudemarketplaces.com/)\n\n**MCPs**\n\n## Closing Notes[#](#closing-notes)\n\nClaude Code clicked for me only after I stopped treating it like ChatGPT in a terminal. You stop thinking “I need to write this code” and start thinking “I need to set up Claude to write this code well.” The setup is the work. The execution is mostly verification.\n\nA few things that have genuinely changed how I work:\n\n** CLAUDE.md is compounding infrastructure.** Every mistake Claude makes is a rule waiting to be written. After a few weeks of “update CLAUDE.md so you do not repeat this”, the same prompts produce dramatically better output.\n\n** CLAUDE.local.md captures PR feedback.** Your reviewers are giving you free training data. Convert recurring feedback into rules. Let Claude apply them next time.\n\n**Skills are the unit of reusable expertise.** If you find yourself prompting the same instructions twice, that is a skill waiting to be written.\n\n**Subagents over kitchen-sink prompts.** Separate concerns, keep contexts clean, and the quality of every individual task goes up.\n\n**Parallel sessions are the unlock everyone underestimates.** Three Claudes in three worktrees is a different kind of leverage. Try it for a day.\n\nThe real shift happens when you stop thinking of Claude Code as a tool you use to write code and start thinking of it as something you train, configure, and operate. Most people stop at the prompts. Going past that, into the directory structure, skills, agents, plugins, and MCPs, is where it stops feeling like a tool and starts feeling like a teammate.\n\nClaude Code icon by [LobeHub](https://lobehub.com), used under the [Apache 2.0 license](https://github.com/lobehub/lobe-icons/blob/master/LICENSE).", "url": "https://wpnews.pro/news/claude-code-as-a-daily-driver-claude-md-skills-subagents-plugins-and-mcps", "canonical_source": "https://arps18.github.io/posts/claude-code-mastery/", "published_at": "2026-05-27 05:13:39+00:00", "updated_at": "2026-05-27 05:57:49.862533+00:00", "lang": "en", "topics": ["ai-tools", "ai-agents", "large-language-models", "generative-ai", "ai-products"], "entities": ["Claude Code", "Anthropic", "Boris Cherny"], "alternates": {"html": "https://wpnews.pro/news/claude-code-as-a-daily-driver-claude-md-skills-subagents-plugins-and-mcps", "markdown": "https://wpnews.pro/news/claude-code-as-a-daily-driver-claude-md-skills-subagents-plugins-and-mcps.md", "text": "https://wpnews.pro/news/claude-code-as-a-daily-driver-claude-md-skills-subagents-plugins-and-mcps.txt", "jsonld": "https://wpnews.pro/news/claude-code-as-a-daily-driver-claude-md-skills-subagents-plugins-and-mcps.jsonld"}}