#claude-code
40 items tagged #claude-code.
GUIDE 2026-05-11
What 1M context on Opus 4.7 actually buys you (and what it doesn't)
Opus 4.7's 1M-token context window is genuinely useful for large cross-file refactors and multi-document synthesis — but most tasks don't need it, and paying for it blindly is expensive.
GUIDE 2026-05-11
Anthropic's official skill pack: PDF, XLSX, DOCX, PPTX and where they shine
The anthropic-skills pack ships eight skills with Claude Code. Four handle documents. This is what triggers each one, where each earns its keep, and where you should reach for something else.
GUIDE 2026-05-11
Using the brainstorming skill to turn a half-baked idea into a written spec
The brainstorming skill forces a design-first workflow in Claude Code: one question at a time, proposals with tradeoffs, and a committed spec before any code runs.
GUIDE 2026-05-11
A custom MCP server in 60 lines: the minimum viable shape
Build a focused MCP server from scratch using the TypeScript SDK. Covers protocol basics, a real git-log-search example, wiring into Claude Code, and the iteration loop that makes debugging fast.
GUIDE 2026-05-11
Choosing between Opus, Sonnet, and Haiku in Claude Code without overspending
Opus costs roughly 5x Sonnet and 20x Haiku. Routing tasks to the right model is the single highest-leverage cost decision in a Claude Code workflow.
GUIDE 2026-05-11
The systematic-debugging skill: when the agent keeps proposing the wrong fix
Claude Code's default failure mode is guessing at symptoms. The systematic-debugging skill enforces root-cause-first debugging: no fix until the cause is identified.
GUIDE 2026-05-11
Fast mode in Claude Code: when to trade Opus 4.7 for Opus 4.6 speed
Claude Code's /fast toggle switches to Opus 4.6 mid-session. Here's which tasks benefit from the faster model and which ones warrant staying on 4.7.
GUIDE 2026-05-11
Claude Code from zero: installing the CLI and getting through the first useful session
Step-by-step install, first-run auth, and a concrete starting prompt — plus the five mistakes that make beginners give up on Claude Code before it clicks.
GUIDE 2026-05-11
PostToolUse hooks: the after-the-fact watchdog pattern
PostToolUse fires after every Claude Code tool call and can inject context, run formatters, and build audit trails — without blocking the agent mid-task.
GUIDE 2026-05-11
SessionStart hooks: injecting context the model would otherwise miss
SessionStart fires once before any tool calls, letting you inject real-time context—git state, sprint focus, oncall rotation—directly into the model's system prompt for that session.
GUIDE 2026-05-11
Claude Code hooks: where they fire, what they can read, and what they can't
Claude Code hooks run shell commands at deterministic lifecycle points. This guide covers all five events, the JSON contracts each one uses, and which hooks can block versus only observe.
GUIDE 2026-05-11
Claude Code in VS Code and JetBrains: when the IDE extension wins and when the terminal does
Claude Code runs both as a terminal CLI and as IDE extensions for VS Code and JetBrains. The experience differs in ways that matter: here's which surface to use and when.
GUIDE 2026-05-11
Claude Code in a monorepo: directory roots, CLAUDE.md, and not getting lost across packages
Starting Claude Code at the wrong directory in a monorepo costs you context. Here's how to manage session roots, per-package CLAUDE.md files, and cross-package edits without losing your mind.
GUIDE 2026-05-11
MCP on Claude Code: from `mcp__` tool names to a working connection
MCP connects Claude Code to external tools without bundling everything into the agent. Here's how to configure servers, understand the tool-naming convention, and debug a server that won't show up.
GUIDE 2026-05-11
Three MCP servers worth installing: Postgres, Notion, and Linear
Postgres, Notion, and Linear MCP servers extend Claude Code with live data access. Each has a clear use case and a specific gotcha that bites you if you skip the setup details.
GUIDE 2026-05-11
MCP tools and Claude Code's tool-use loop: how they actually compose
Native tools and MCP tools look identical to the model. Understanding the lifecycle differences—and what happens when the tool list grows too large—makes MCP integrations reliable.
GUIDE 2026-05-11
Output token budgets in Claude Code: avoiding the truncation surprise
Claude Code's output token ceiling—not your context window—is what cuts long generations short. Here's how to spot truncation early and structure requests to stay under the limit.
GUIDE 2026-05-11
Claude Code permission modes: plan, edit, and auto-accept — and when to switch
Claude Code's three permission modes gate different levels of agent autonomy. Getting the mode wrong costs you either hours of unnecessary round-trips or a destructive operation you can't undo.
GUIDE 2026-05-11
Plan mode in Claude Code: the conversation step that prevents thrash
Claude Code's plan mode produces a written proposal with no file edits or commands. Here's when to use it, how to refine plans through dialogue, and when to skip it.
GUIDE 2026-05-11
Claude Code plugins vs skills: the same thing or two different things?
Plugin and skill are related but not interchangeable. A plugin is the installable package; a skill is the unit of behavior inside it. Getting the distinction right changes how you build, version, and share reusable workflows.
GUIDE 2026-05-11
Prompt caching on Claude Code: the 5-minute TTL and how to actually save money
Claude Code's prompt caching has a 5-minute TTL. Understanding that clock shapes how you structure sessions and which habits quietly drain your budget.
GUIDE 2026-05-11
Resuming Claude Code sessions without re-explaining the entire task
Claude Code stores conversation history locally. Here's how to resume sessions with --continue and session IDs, when it works well, when it doesn't, and one habit that makes re-entry fast.
GUIDE 2026-05-11
How Claude Code decides which skill to invoke (and how to influence that)
Claude Code's orchestrator routes tasks to skills by reading their descriptions. Here's exactly how that matching works, why competing descriptions cause routing failures, and how to fix them.
GUIDE 2026-05-11
Tuning a Claude Code skill's frontmatter: getting the description right
Claude Code reads a skill's description field to decide when to invoke it. A vague description means the skill never triggers; an overly broad one fires on everything. Here's how to write one that routes correctly.
GUIDE 2026-05-11
Skill or hook? Two extension points and how to choose
Claude Code has two extension points: skills run inside the model's loop, hooks run in the harness around it. Knowing which to reach for determines whether your automation is reliable or just suggestive.
GUIDE 2026-05-11
Skill or MCP server? Where the boundary actually is
Skills shape how Claude Code thinks and works. MCP servers give it new tools to call. Confusing the two leads to building the wrong thing.
GUIDE 2026-05-11
Claude Code skills: why they exist when prompt templates already worked
Claude Code skills are dynamically loaded behavior packages — only invoked when relevant. Here's why that matters and how the distribution model actually works.
GUIDE 2026-05-11
Slash commands and keybindings: the parts of Claude Code most people don't customize
Claude Code's built-in slash commands, user-defined skill triggers, and keybindings.json are all configurable — most users never touch them.
GUIDE 2026-05-11
Claude Code streaming output: what it costs and what it buys you
Claude Code streams tokens as they're generated, so you see output in under a second instead of waiting 30 seconds for silence. Here's when that trade is worth it and when it isn't.
GUIDE 2026-05-11
Claude Code subagents: when to dispatch and when to keep the main session
Subagents give Claude Code an isolated context window for grunt work. Here's when that matters, when parallel dispatch pays off, and when it backfires.
GUIDE 2026-05-11
The Superpowers skill suite: what it covers and what it deliberately doesn't
Superpowers is a community skill pack for Claude Code that enforces a consistent workflow: brainstorm, plan, execute, review. Here's what each skill does and where the suite draws its own boundary.
GUIDE 2026-05-11
The test-driven-development skill: TDD as a tool-use discipline
Claude Code skips the failing-test step without enforcement. The TDD skill closes that gap by requiring a visible failing run before implementation is allowed to start.
GUIDE 2026-05-11
Building a team-shared skill library that doesn't decay in six months
A git-tracked shared skill library prevents duplicate work and knowledge loss when engineers leave. This guide covers repo structure, naming conventions, deprecation process, and CLAUDE.md as a skill index.
GUIDE 2026-05-11
Extended thinking on Claude Code: where the extra tokens earn their keep
Extended thinking lets Claude reason silently before answering — useful for hard problems, wasteful on simple ones. Here's how to tell the difference and read the trace when things go sideways.
GUIDE 2026-05-11
verification-before-completion: stop claiming work is done when it isn't
Claude Code's verification-before-completion skill enforces a simple rule: every 'done' claim must be backed by real output. No test runs summarized from memory. No lint passes assumed.
GUIDE 2026-05-11
Claude Code vs Cursor: same task, two tools, what actually differs
Run the same multi-file refactor through both tools and the ergonomic gap becomes concrete: Cursor wins on inline completion flow; Claude Code wins on coordinated multi-file changes. The real question is where each fits in your day.
GUIDE 2026-05-11
Writing your first Claude Code skill: from idea to triggered execution
Claude Code skills let you encode repeatable workflows as prompt-driven commands. This guide walks through writing a real skill end to end—frontmatter, body, install, and debugging.
GUIDE 2026-05-11
Pairing writing-plans and executing-plans: the spec-to-merge pipeline
How to use Claude Code's writing-plans and executing-plans skills together — from a vague spec to a checkboxed plan with exact file paths, complete code, and a clean execution run.
GUIDE 2026-05-11
Codex vs Claude Code: same job, different model families — concrete differences
Both run in your terminal, read your codebase, and execute autonomous tasks. What's different is how GPT-family and Claude-family models approach the same problem — and those differences are visible and reproducible.
