✨ Featured · Announcements
Introducing cctk: the Claude Code Toolkit
A community-vetted collection of slash commands, subagents, hooks, and MCP integrations. One install, sensible defaults, deeply customizable.
Blog · 11 posts
The Claude Code Toolkit blog
Deep dives on workflows, patterns, and case studies. Written by developers who ship with Claude Code every day.
Patterns
Claude Code for code archaeology: understanding old code faster
The unglamorous but high-value use case that gets ignored in most Claude Code content — using it to understand code you didn't write.
Deep dives
The "AI as intern" mental model: where it works and where it breaks
The most popular framing for AI coding tools compares them to a smart intern. Where the analogy holds, where it doesn't, and what to use instead.
Deep dives
5 hooks we removed and why
Not every hook that seemed valuable stayed valuable. The five we retired, the specific failure modes that killed them, and the meta-lessons.
Deep dives
Testing your subagents: patterns that catch bad prompts
A subagent prompt is code, and code needs tests. Six patterns for testing subagents in ways that catch prompt regressions.
Patterns
Onboarding to a Claude-Code-native codebase: the new-hire perspective
I joined the team three months ago with 200+ commands, subagents, hooks, and skills. What worked, what didn't, and what teams should do differently.
Deep dives
Prompt caching that actually pays back: 4 patterns
Enabling prompt caching is easy. Getting meaningful savings from it is where most teams stall. Four specific patterns we've validated in production.
Deep dives
CLAUDE.md is a product, not documentation
The framing that fixed how we write, maintain, and iterate on our CLAUDE.md. Treat it like documentation and it decays. Treat it like a product with users, feedback loops, and outcomes, and it stays useful.
Deep dives
How we version-control our subagents (and why we started)
For six months we treated subagents like config files: commit them to git, done. Then a "small tweak" broke twelve engineers' workflows silently for a week. This is the version control discipline we adopted after that.
Deep dives
The "second reader" pattern: subagents that review other subagents' output
One subagent produces output. A second subagent reviews it before shipping. This isn't just belt-and-suspenders — the second reader catches a specific class of failure the primary can't catch on its own.
Deep dives
Cost accounting for AI-assisted work: what actually shows up on the bill
The first month your team's Anthropic bill hits four figures, someone will ask "where is this coming from?" The answer is less obvious than you'd think. Here's the actual anatomy of an AI-assisted-work bill.
Deep dives
The context-window budget: treating tokens like a scarce resource
Context windows have grown to 200K+ tokens. That looks like abundance. In practice, it isn't — attention degrades before the window fills, and every token loaded competes for that attention.
Anti-patterns
Your slash commands shouldn't have branching logic
The moment your slash command's definition contains "if the user wants X, do Y; otherwise do Z," you've outgrown the primitive. Branching logic in slash commands is one of those anti-patterns that seems reasonable until you've watched it fail.
Deep dives
The "one subagent per task" rule and when to break it
The rule works about 80% of the time. The other 20% is where subagent design gets interesting. Here's when to follow the rule, when to combine, when to split further, and how to tell which situation you're in.
Deep dives
How we structure prompts for agentic loops that don't spiral
Every team building with agentic loops has watched one spiral — 40 minutes, $30 in tokens, confident wrong output. The fix isn't model choice or better tools. It's prompt structure. Here's the three-part structure that made our loops boring.
Deep dives
The migration from ad-hoc prompts to a subagent library
For a year, our team used Claude Code with ad-hoc prompts — each engineer building their own. It worked until it didn't. This is the story of migrating to a shared subagent library: the trigger, the extraction methodology, the mistakes, and where we landed.
Deep dives
Skills vs subagents vs slash commands: a decision tree that actually works
The three primitives look similar in the docs. In practice they solve different problems, and picking the wrong one produces surprisingly bad outcomes. A decision tree that our team actually uses, plus six scenarios walked through.
Anti-patterns
Stop writing 5000-word CLAUDE.md files
Every session pays the token tax. Every engineer scrolls past most of it. Every update is a merge conflict waiting to happen. Here's why big CLAUDE.md files are worse than useless and what to do with the content instead.
Anti-patterns
Your MCP server doesn't need 40 tools
The default MCP server design pattern is "expose every capability of the underlying service." It's the wrong pattern. Focused MCPs beat comprehensive MCPs in almost every deployment. Here's why, and how to build the focused version.
Patterns
6 Claude Code patterns we ship every week
The workflows that turn Claude Code from "cool AI tool" into "how our team actually gets work done" — with the specific commands, agents, and hooks that make each one work.
Case study
How we cut PR review time by 40% with Claude Code subagents
Six months of measured data on pr-reviewer subagent adoption. What worked, what didn't, and the honest limits of AI-assisted code review.
Deep dives
The 12 lifecycle hooks every team should install
Claude Code hooks are the most underrated part of the platform. These twelve turn team standards from "we should really enforce that" into invariants that get enforced automatically.
Technical decisions
Why we picked MCP over custom integrations for Sentry
We had a working custom Sentry integration for Claude Code. We rewrote it as an MCP server. Here's the honest tradeoff analysis and what we learned six months later.
Case Studies
Cursor to Claude Code: what actually changed in 6 weeks
A dozen devs, one migration, and the parts nobody warned us about. Written from the middle, not the end.
Deep Dives
5 anti-patterns we removed from our CLAUDE.md
The most valuable file in your repo is also the easiest to make worse. Concrete before/after examples from real teams.
Technical Decisions
How we route between Claude models: the cost / context / quality triangle
Not every task needs Opus. Not every task can survive Haiku. A framework and specific numbers from three months of production routing.
Case Studies
The hook that prevented a production outage last Tuesday
A short story about a `DROP TABLE`, a lifecycle hook, and the thin line between an AI agent that's helpful and one that's dangerous.
Case Studies
Claude Code in a fintech, three months in
A regulated-environment deployment story. What worked, what didn't, and what surprised our compliance team more than us.
Deep Dives
Skills, commands, subagents: when to use which
Three primitives that overlap enough to confuse teams. A decision framework and the specific rules we use to pick.
Deep Dives
MCP server security: what to audit before you add one
A checklist for evaluating MCP servers before they touch your production data — permissions, provenance, network scope, and the questions our team asks every time.
Patterns
Claude Code in GitHub Actions: 8 automation patterns
How to run Claude Code from CI to review PRs, backfill tests, sweep docs, and catch regressions — with workflow YAML and hard-earned lessons on cost, quotas, and idempotency.
Deep Dives
CLAUDE.md at scale: patterns for 100+ file monorepos
How to structure CLAUDE.md files so context stays useful across a large codebase — hierarchical layouts, scoped instructions, and the anti-patterns that make big monorepos worse.
Deep Dives
Subagent design principles: what we learned building 30+
The design rules we settled on after building thirty-plus subagents in production — scope, prompts, tool selection, and the failure modes that shaped every rule.
Case Studies
How we reduced our Claude Code bill by 62% (without cutting usage)
A specific breakdown of where our tokens were going, what we changed, and the six optimizations that produced most of the savings — without asking anyone to use Claude less.
Deep Dives
Custom skills for domain workflows: a walkthrough
How to build a Claude Skill for a real domain workflow — the design, the file layout, the mistakes we made, and what to check before you ship one to your team.
Deep Dives
When Claude Code is the wrong tool: a taxonomy
Six categories of work where we've stopped reaching for Claude Code, why, and what we use instead. An honest counter to "AI-first everything" thinking that's hurt more than it helped.
Patterns
Voice mode with Claude Code: 6 weeks of production observations
What actually changed when we started using Claude Code hands-free during commutes, walks, and cooking. The workflows that work, the ones that don't, and the interaction patterns nobody warned us about.
Case Study
Rolling out Claude Code to 60 engineers: what worked and what didn't
A staged rollout over four months across a 60-engineer team. The onboarding path that stuck, the resistance patterns we didn't anticipate, and the metrics we actually watched.
Deep Dives
Metrics that matter: measuring Claude Code impact honestly
Most AI productivity metrics are performative. Here's the smaller set that actually predicts whether Claude Code is helping your team — and why the popular ones don't.
Deep Dives
Building compliance-friendly Claude Code workflows for regulated industries
Financial, healthcare, and government workflows have constraints that most Claude Code content ignores. The audit trails, data boundaries, and approval patterns that make it work in regulated environments.
Patterns
How our on-call runbook uses Claude Code
The specific ways Claude Code changed our on-call rotation — from initial page to postmortem — with the commands, subagents, and human checkpoints that make it survive real production stress.