If you've been living under a rock, Claude Code is Anthropic's CLI that reads your entire codebase, edits files, runs commands, and ships commits — no GitHub web UI, no chat-history context switching. It's currently the fastest way to maintain production codebases with an AI collaborator.
But Claude Code alone is half the story. Skills (workflow modules) and MCP servers (external integrations) multiply what Claude can do and where it can do it. This piece covers what actually lives in my setup for shipping Rebuild Relief + Aidxn Design client work in 2026. Not theory. Real files, real servers, real outcomes.
What Are Skills and MCP Servers Anyway?
Skills are workflow modules you install into Claude Code. They're Anthropic-curated tools that scaffold common jobs — brainstorming, debugging, writing plans, dispatching parallel agents. They load automatically at session start and live in `~/.claude/skills/`.
MCP servers are external integrations. They connect Claude to databases (Supabase), hosting platforms (Netlify), documentation (context7), and browser automation (Playwright, PinchTab). MCP = Model Context Protocol. When Claude has an MCP server connected, it can read your Netlify deploy logs, run SQL on your database, fetch live API docs, and take screenshots without leaving the conversation.
Together: skills handle the meta-work (planning, debugging, parallel dispatch), MCPs handle the external work (talking to your actual infrastructure). The composition is what makes the loop fast.
My Skill Stack (and Why Each Lives Here)
superpowers — brainstorming, planning, systematic debugging, TDD scaffolding, parallel agent dispatch, code review requests. Auto-loaded. This is the default-on workflow engine for anything non-trivial. Saves ~20% of conversation turns by making you think before you build.
caveman — ultra-compressed comms mode (~75% token savings). I invoke this explicitly before dispatching 2+ parallel sub-agents or scanning 10+ files in parallel. It's not always-on because brevity makes debugging explanations less clear; I switch back to normal mode when reasoning matters.
frontend-design — design-engineering helper for UI craft. Component naming, layout patterns, accessibility. Not for every session, but indispensable for visual polish on Aidxn projects where the design *is* the product.
code-simplifier — code review + refactor. Runs after I've finished a feature and want a second look. Catches the "this logic could be half the lines" moments.
claude-md-management — CLAUDE.md audit and improvement. I run this monthly to keep project memory up-to-date without manually editing nine files.
What's NOT in my stack: feature-dev (too prescriptive), ralph-loop (rarely needed), Cavekit / cavekit-local (disabled 2026-05-14). I used to run Cavekit for bulk refactors; now I use caveman + superpowers dispatch instead.
My MCP Stack (and the One That Matters Most)
Supabase — database reads, schema inspection, SQL execution. Connected to both my personal Supabase and Rebuild Relief's. Critical for any project touching Postgres. Auto-loaded at session start.
Netlify — deploy logs, env vars, function inspection, deploy preview URLs. I almost never manually SSH into a server anymore; everything flows through Netlify's MCP interface.
context7 — live documentation for libraries / APIs. I load this before touching anything I'm not 100% certain about (Astro APIs, shadcn/ui prop shapes, Zod schema syntax). Training data can lag; live docs never do.
Playwright — browser automation for visual verification. Non-negotiable for any UI work. The Hard Rule is written into my CLAUDE.md: "Never claim visual/UI work is done without launching the browser, navigating to the page, and screenshotting desktop + mobile."
What I don't use: ChatGPT MCP, Claude-in-Chrome (PinchTab is faster). What I would use if I had the infrastructure: Stripe (payments), DataDog (logs), GitHub Advanced Security (scanning).
The Session-Start Flow
When I `claude-code` into a project directory:
1. Claude reads `/CLAUDE.md` at the root (project-specific instructions, team voice, hard rules).
2. Skills auto-load: superpowers, caveman, frontend-design, code-simplifier, claude-md-management. These are symlinked in `~/.claude/skills/`.
3. MCP servers connect: Supabase (asks which project first), Netlify (same), context7 (always), Playwright (on-demand).
4. Claude reads the CLAUDE.md's "Memory Index" section, which points to local markdown files documenting: brand voice, tech stack, recent learnings, deploy targets, git conventions.
I'm now in a session where Claude already knows the project, already has the tools loaded, and is ready to take a brief with 100% context retention. No onboarding every time. The setup cost is paid back inside day one.
How They Compose Into Real Work
Example: I brief Claude to "update the Rebuild Relief blog with three new posts about storm-damage assessments". Here's what happens:
Claude reads CLAUDE.md, loads the blogging rules from `docs/claude/BLOG.md`. It sees that posts are Fireship-style (2–3 sentence paragraphs, code-first, opinions), live in `/src/pages/blog/`, and use a specific Astro template. It branches off and uses superpowers/brainstorming to outline the three posts before writing a word. I see the outline, approve it or iterate. Claude then writes all three posts, runs context7 to double-check technical claims, uses Netlify MCP to check the deploy preview after pushing the branch. I click the preview URL, eyeball the posts on the live site, and either merge or ask for revisions. Total loop: ~30 minutes. Without skills + MCPs, same job would be 2–3 hours of back-and-forth clarification.
Second example: I spot a performance regression on the Rebuild Relief client site. Claude uses Netlify MCP to grab the recent deploy logs, reads them for errors. It finds a TypeScript build warning that should've been an error. It uses context7 to understand the exact tsconfig rule, then fixes the config and the offending code in two commits. Playwright screenshots the before/after to confirm the build time improved. All in the session, no manual investigative work.
The Skills That Actually Earn Their Weight
superpowers/brainstorming — most valuable. Forces a moment of thinking before building. Sketches out design, architecture, acceptance criteria. The difference between "I'm not sure what I want" and "here's exactly what I want, build it".
superpowers/systematic-debugging — saves hours. When something breaks, Claude doesn't guess. It methodically reads stack traces, isolates the root cause, proposes a fix, tests it, and repeats until the problem is solved. "What's wrong?" prompts without this usually produce wrong answers.
superpowers/dispatching-parallel-agents — high ROI for high-parallelism work (audit 20 files, refactor 5 components). With caveman mode enabled, the output is compressed but readable. Without dispatch, you'd hit the same 5 files sequentially and waste time.
MCP-wise, Supabase and Netlify are non-negotiable for production work. context7 saves me from browsing docs. Playwright prevents UI regressions. Those four cover 95% of the value.
Common Questions
Can I run this setup locally? Supabase, Netlify, Playwright yes. context7 yes. You'll need a `.claude/config.json` file that points Claude to your MCP server binaries (or Netlify/Supabase API tokens). Supabase offers local dev; Netlify you'll interact with remotely. Set it up once, then forget it.
How do skills differ from vanilla Claude? Vanilla Claude is a completion engine — you prompt it, it responds. Skills change that: they're opinionated workflows that structure the session differently. Brainstorming skill doesn't just write brainstorm ideas, it runs a 5-turn loop asking you questions, refining the brief each turn. The output is better thought-through.
What about cost? Skills are free (bundled with Claude Code). MCP servers are free (they're integrations). Claude API calls cost money — the usual $0.50–$2 per complex session depending on model. For production client work, the API cost is rounding-error vs developer time.
Can I add custom skills? Yes — they live in `~/.claude/skills/` as folders with a `skill.json` schema + markdown files. I haven't written a custom skill yet; the Anthropic-curated ones cover my needs. But it's possible for domain-specific workflows (e.g., a "billing audit" skill if you had bespoke payment rules).
The Bottom Line
Skills + MCP servers aren't required for Claude Code to work. But they're required for Claude Code to work *well* on production codebases. The difference between "Claude Code is useful" and "Claude Code is faster than shipping actual developers" is in the setup: a solid CLAUDE.md, skills loaded, and MCPs connected to your actual infrastructure. Spend 2–3 hours on this setup once per project, and you get 3–5x faster iteration cycles for the life of the project. The ROI compounds. Start with superpowers + Supabase + Netlify. Add context7 and Playwright next. That's 80% of the value right there.