My Daily Claude Code Toolkit: MCPs, Skills, and the Tools That Stick

The right tool for the job

I wrote a post a while back about how to actually use AI for development — principles like planning before prompting, managing context windows, and running parallel agents with git worktrees. That post is about mindset and workflow. This one is about the specific tools sitting underneath that workflow.

Not all of these are MCPs. Some are MCP servers — plugins that give Claude access to external capabilities like browser control or live documentation. One is a skills framework that reshapes how Claude approaches the entire development process. They're different kinds of tools but they all live in the same daily workflow.

After months of experimenting, I've settled on five that I use on almost every project. Here's what they are and what I actually use them for.

A quick note on setup

MCPs (Model Context Protocol servers) are configured via the CLI (claude mcp add) or directly in ~/.claude/settings.json. Each runs as a server process Claude communicates with during a session. You can scope them globally or per-project.

Skills frameworks like Superpowers work differently — they're installed as plugins and provide skill files (structured markdown documents) that Claude reads and follows automatically. No manual invocation needed; they trigger based on context.

All five tools below are installed globally on my machine.

Serena — code intelligence through language servers

The most transformative tool in my stack. Serena is an MCP that wraps Language Server Protocol (LSP) — the same underlying technology that powers IDE features like go-to-definition, find-all-references, and symbol search.

Without Serena, Claude navigates your codebase the way a junior developer navigates an unfamiliar project on their first day: by grep-ing, reading directory listings, and making educated guesses. With Serena, it navigates the way someone who has been working in the codebase for months navigates it: by understanding symbols, types, and call graphs.

What it enables

Go to definition — Claude can jump directly to where a function, type, or variable is defined instead of searching for it
Find all references — instantly find every place a symbol is used across the entire project
Symbol search — locate any class, function, or type by name without knowing which file it's in
Hover types — understand what a value actually is at any point in the code

Where I actually use it

The biggest win is cross-file refactors. Say I have a utility function that's been around for two years and I want to rename it or change its signature. With a normal Claude session, finding all the callers involves careful grepping and hoping nothing was missed. With Serena, Claude calls find-references and gets an exhaustive list — files, line numbers, exact call sites — before touching a single line of code.

It also pays dividends on large codebases I don't fully know. When I join a client project and need to understand how a particular API route is wired up — what middleware runs, what services it calls, what types flow through it — Serena lets Claude trace that path accurately rather than piecing it together from file reads.

The setup requires a language server compatible with your project (e.g., typescript-language-server for TypeScript projects, gopls for Go). Once configured, it's transparent — Claude just uses it.

Playwright MCP — Claude controlling a real browser

Playwright MCP is exactly what it sounds like: it gives Claude the ability to drive a real browser. Navigate to a URL, take a screenshot, click buttons, fill in forms, read page content, run JavaScript — all of it.

The official MCP is maintained by Microsoft alongside the Playwright project itself, which means it's well-maintained and keeps pace with Playwright updates.

What it enables

Screenshots on demand — Claude can capture a page at any point during a task
Interaction — click elements, type into inputs, submit forms, navigate between pages
Page state reading — access the DOM, read text content, check what's visible
Multi-step flows — execute sequences of actions (log in, navigate to dashboard, verify a value)

Where I actually use it

The most frequent use case for me is visual verification after UI changes. I'll ask Claude to make a CSS adjustment, and instead of me alt-tabbing to a browser to check it, Claude screenshots the page before and after and tells me what changed. This is surprisingly effective for catching regressions — "the spacing on mobile got worse" — without me having to manually inspect every breakpoint.

The second use case is testing auth flows. When I'm working on an OAuth integration or a login flow, I can ask Claude to walk through the actual user journey: open the page, click sign in, complete the form, verify the redirect. It's not a replacement for proper E2E test suites, but for spot-checking during development it's fast and concrete.

I also use it for quick scraping tasks. Instead of writing a scraper, describing what data I need and pointing Claude at the URL is often enough for one-off data extraction.

One thing worth knowing: the MCP launches a real browser process (with a --headed option to make it visible). For CI or automated runs you'll want headless mode; for local development, watching Claude click through your app in real time is genuinely useful for spotting UX issues.

Sequential Thinking — structured reasoning for hard problems

This one from Anthropic's official MCP servers collection is less about external capabilities and more about how Claude reasons. The Sequential Thinking MCP provides a tool that lets Claude work through problems in explicit, tracked steps — thinking out loud in a structured way rather than jumping to conclusions.

It's particularly useful for problems where the solution space is large, the dependencies between decisions matter, or getting the wrong first step means all subsequent steps are wrong.

What it enables

Step-by-step decomposition — Claude breaks a problem into a numbered sequence of reasoning steps before acting
Revision support — steps can be marked as needing revision; Claude can backtrack and correct earlier reasoning
Branching thoughts — different solution paths can be explored and compared before committing
Transparent reasoning — the chain of thought is visible and auditable, not hidden inside a single response

Where I actually use it

Architecture decisions are the main use case. When I'm designing a new data model or choosing between two approaches for a service boundary, I'll explicitly invoke sequential thinking to walk through the trade-offs systematically. Claude stops treating it as a quick judgment call and actually evaluates each option against the constraints.

The other high-value case is debugging complex issues — particularly cascade failures or race conditions where the cause is several layers removed from the symptom. I had a bug recently where a WebSocket client was occasionally missing messages during reconnection. The root cause turned out to be a combination of event handler registration timing and reconnection backoff behavior. With sequential thinking active, Claude worked through the possible failure modes one by one rather than immediately proposing the first fix that came to mind. It found the right cause on the first attempt.

You can trigger it explicitly ("use sequential thinking for this") or configure Claude to invoke it automatically for certain types of tasks. I do both — automatic for architecture tasks, explicit for debugging.

Superpowers — a structured development workflow as a skill set

Superpowers by Jesse Vincent is unlike the other tools on this list. It's not an MCP — it's a skills framework: a curated collection of structured workflow skills that Claude automatically follows when relevant. Installing it changes how Claude approaches software development at a process level, not just a capability level.

The core philosophy is four things: test-driven development, systematic processes over intuition, complexity reduction, and evidence-based verification. These aren't suggestions — they're enforced patterns built into the skills.

What it enforces

The framework shapes Claude's behaviour across the full development lifecycle:

Design phase — Claude asks clarifying questions before writing a single line, refines requirements through back-and-forth, and presents designs in digestible sections for approval before proceeding
Planning phase — approved designs get converted into bite-sized implementation tasks (2–5 minutes each), each with specific file paths, complete code context, and verification steps
Execution phase — tasks are dispatched to fresh subagents with isolated git worktrees; each subagent gets a two-stage code review on completion: spec compliance first, then code quality
TDD enforcement — the RED-GREEN-REFACTOR cycle is mandatory; if tests weren't written before implementation, the code gets deleted and redone correctly
Debugging methodology — systematic four-phase root cause analysis instead of "try things until something works"

Where I actually use it

The biggest payoff is on non-trivial features where the temptation to just start coding is high. Superpowers forces a design conversation first. That conversation almost always reveals assumptions I hadn't examined — edge cases, integration points, constraints that change the implementation approach. Catching those before writing code is worth a lot.

The planning phase output is also genuinely useful on its own. Even when I end up doing tasks manually rather than through subagents, having bite-sized chunks with explicit verification steps makes progress easier to track and review.

The TDD enforcement is uncomfortable at first if you're not used to writing tests before implementation. After a while it's just how you work, and you notice the gap when it's absent.

Install it via the Claude Code plugin marketplace by searching for "superpowers", or manually by following the instructions in the GitHub repo. Once installed, the skills activate automatically — you don't need to invoke them explicitly.

Context7 — always-fresh library documentation

The problem this solves is simple and serious: Claude's training data has a cutoff date. Libraries don't. Next.js is on version 15 with the App Router having changed significantly. Tailwind CSS is on version 4 with a completely different configuration model. React 19 introduced APIs that didn't exist when Claude's training ended.

Without fresh documentation, Claude makes confident-sounding mistakes. It generates code that uses deprecated APIs, misses new patterns, or simply doesn't know about features that exist.

Context7 fixes this by fetching live, up-to-date documentation for any library on demand. When Claude needs to know how something works in a current version, it queries Context7 instead of relying on training data.

What it enables

Current API reference — fetch the actual documentation for any library version
Migration guides — get the official guide for upgrading between major versions
Example code — pull real, current usage examples from official docs
On-demand lookup — no configuration needed per-library; just ask about what you need

Where I actually use it

Every time I work with a library that's moved significantly in the last year. This is more often than I'd like — Next.js, Tailwind, shadcn/ui, Drizzle ORM, and Hono have all changed enough that relying on Claude's training data alone produces wrong answers regularly.

The workflow is simple: when Claude starts generating code that involves a library API I'm not sure is current, I tell it to check Context7 first. It fetches the relevant documentation, then generates code based on that. The difference in accuracy is night and day for fast-moving libraries.

I've also found it valuable when working with internal or less-common libraries that wouldn't have much representation in Claude's training data at all. If the library has public docs, Context7 can fetch them.

One practical tip: mention the specific version you're targeting ("use Context7 to check the Next.js 15 docs for this"). The more specific you are, the more precise the documentation fetch.

How they work together

The real value comes when these tools combine in a single workflow. Here's what a realistic session looks like:

I'm adding a new API route to a Next.js project that's already running in production. The route needs to interface with an existing service layer, follow the project's auth patterns, and use some newer Next.js App Router features I'm less familiar with.

Superpowers kicks in first — before any code gets written, Claude asks clarifying questions about the route's requirements, presents the design, and plans the implementation as discrete tasks
Serena navigates the existing service layer — go-to-definition on the relevant interfaces, find-references to understand how similar routes consume them
Context7 fetches the Next.js 15 documentation for Route Handlers and the caching behaviour I need to configure correctly
Sequential Thinking works through edge cases — auth failure paths, caching invalidation, error response shapes
Playwright MCP verifies the finished route in a real browser — actually hits the endpoint, checks the response, confirms the auth middleware is behaving correctly

None of these tools is doing something I couldn't do manually with enough effort. What they do is compress the time between "starting a task" and "having something correct" by removing friction at each step.

Final thoughts

These five tools are daily drivers, not experiments. Each one addresses a real gap:

Serena removes navigational guesswork in large codebases
Playwright MCP makes visual and E2E verification fast
Sequential Thinking improves reasoning on hard problems
Superpowers enforces a disciplined development process end-to-end
Context7 keeps library documentation current

If you're new to extending Claude Code, start with Context7 — it has the most immediate impact. Then Serena if you work in large codebases. Superpowers if you want your whole development process to tighten up.

If you've got tools in your own Claude Code setup that aren't on this list, I'd genuinely like to hear about them.