The 31-Tool Claude Code Stack That Senior DevOps Engineers Are Actually Using

Quick Navigation

Difficulty: Intermediate
Estimated Time: 15-25 minutes
Prerequisites: Claude Code installed, basic DevOps workflow experience, familiarity with MCP servers, Git and GitHub usage

After sifting through hundreds of community plugins, MCPs, and orchestration tools, a clear professional-grade stack has emerged — and the choices reveal something important about where AI-assisted engineering is headed.

There are now over 200 community-built extensions for Claude Code. Most of them are toys. A handful are genuinely load-bearing infrastructure. The difference between a developer who uses Claude Code as a fancy autocomplete and one who uses it to run autonomous overnight migrations comes down almost entirely to which 30 tools they've installed — and in which order.

This is not a list of everything that exists. It's a curated, redundancy-resolved stack for developers and DevOps engineers who treat Claude Code as a production system, not a demo. Every tool on this list has been evaluated against the others in its category. Where two tools overlapped, one was cut.

What follows is that stack, why it's built the way it is, and what the shape of it tells us about the state of AI-native development in 2026.

Part 1: The Foundation Layer — Four Tools That Everything Else Depends On

Before you install anything else, you need to answer a question most developers skip: what does Claude Code not have access to that it needs? The answer is almost always the same three things — your filesystem, your repositories, and accurate documentation for the libraries you're actually using.

The Filesystem MCP (score: 9.0) is table stakes. Without it, Claude Code can reason about code but can't read or write files in any structured way. It's the plumbing. Install it first, before anything else, before you even think about what else you want.

The GitHub MCP (score: 9.2) removes what practitioners identify as the single largest context bottleneck in AI-assisted development: the gap between what Claude knows about your codebase and what's actually in your PRs, issues, and commit history. Once connected, Claude Code can search code, analyze open pull requests, and surface issue context without you copy-pasting anything.

The context7 MCP (score: 9.4 — the highest in the foundation tier) solves a different problem: hallucination on library APIs. Claude's training data contains documentation for React, Next.js, Tailwind, and dozens of other frameworks — but those docs are frozen at a point in time. context7 pulls real-time, version-accurate documentation at query time, which means Claude stops confidently suggesting APIs that were deprecated two major versions ago.

"Real-time version-accurate docs mean zero hallucinations on React/Next/Tailwind. That's not a quality-of-life improvement — it's a correctness guarantee."

Rounding out the foundation layer: ccusage (score: 9.6, 11.8K GitHub stars), the de facto standard for tracking token consumption and cost per session. It's not a development tool in the traditional sense, but operating Claude Code without it is like running cloud infrastructure without billing alerts.

Key insight: context7 exists as both a skill plugin and an MCP server. Install only the MCP. It covers both use cases, and installing both creates redundant overhead.

Part 2: Official Plugins — The Seven That Belong in Every Dev Workflow

The official plugin ecosystem is smaller than the community ecosystem but substantially more reliable. Six plugins belong in a standard dev setup regardless of stack.

feature-dev (score: 9.1) implements a 7-phase development workflow: spec, test, implement, review, and three intermediate phases for validation and cleanup. Field reports consistently put the bug catch rate at 3–5 real bugs per branch. That's not a marginal improvement — it's a structural change in how defects enter the codebase.

commit-commands (score: 8.8) gives you /commit, /commit-push-pr, and /clean_gone as first-class Claude Code commands. Git automation at the command level means the mechanical parts of a PR cycle stop requiring context switches.

code-review (score: 8.8) runs 5 parallel review agents with confidence scoring. Use it before every merge. The parallel agent architecture matters because different agents catch different defect classes — one agent focused on security won't notice the same issues as one focused on performance.

pr-review-toolkit (score: 8.5) runs 6 specialized agents and is strictly more thorough than code-review for large PRs. The tradeoff is runtime. For small changes, code-review is faster. For anything significant, reach for pr-review-toolkit.

security-guidance (score: 8.6) scans for 9 vulnerability patterns on every file edit, automatically, without any user action. Zero-friction security coverage is categorically different from security tooling you have to remember to run.

ralph-wiggum (score: 8.1) enables autonomous unattended loops — the tool you reach for when you want Claude Code to run a migration, expand test coverage, or upgrade a dependency tree while you're not at the keyboard.

Part 3: Language Server Protocol — The Invisible Infrastructure Most Developers Skip

LSP support in Claude Code is underappreciated. The language server plugins provide real-time type checking, go-to-definition, and error surfaces that make Claude Code dramatically more accurate when working within a typed codebase.

The available plugins cover the major languages: TypeScript/JavaScript via typescript-lsp (score: 9.0), Python via pyright-lsp (score: 9.0), Go via gopls-lsp (score: 8.5), Rust via rust-analyzer-lsp (score: 8.5), C/C++ via clangd-lsp (score: 7.9), and Java/Kotlin via jdtls-lsp and kotlin-lsp.

The install command is identical across all of them: /plugin install typescript-lsp (substituting your language). There's no reason not to install the LSP for every language in your active stack.

Note: LSP integration doesn't just help Claude catch errors — it gives Claude access to the same semantic understanding of your codebase that your IDE has. That's a qualitative difference, not an incremental one.

Part 4: DevOps-Specific MCPs — Closing the Loop Between Code and Infrastructure

The general-purpose foundation layer gets Claude Code into your filesystem and repositories. The DevOps MCP tier connects it to the rest of the systems that production engineering actually touches.

PostgreSQL MCP (score: 8.5) enables plain-language database queries and schema inspection. This sounds simple; in practice it means debugging data issues without writing SQL by hand, and explaining schema relationships to Claude without pasting DDL.

Sentry MCP (score: 8.2) brings error tracking, stack traces, and issue analysis inline. When production breaks, the context for understanding why is in Sentry. Having Claude Code access that context without a browser switch changes the shape of incident response.

Playwright MCP (score: 9.0) handles end-to-end testing and infrastructure smoke tests using an accessibility tree rather than DOM scraping — which keeps token costs manageable. This is also the reason Puppeteer MCP was cut from this stack. Playwright scores 9.0 against Puppeteer's 7.0 and handles everything Puppeteer does.

Firecrawl MCP (score: 9.1) scrapes runbooks, vendor documentation, and internal wikis with full JavaScript rendering and anti-bot bypass. When your runbooks live behind authenticated portals or JS-heavy pages, Firecrawl gets them into Claude's context.

Jina Reader MCP (score: 8.2) handles the simpler case: fast URL-to-Markdown conversion for public documentation, RFCs, and vendor reference pages. It's cheaper and faster than Firecrawl for the 70% of cases that don't require JS rendering.

Note: Slack MCP (8.5), Linear MCP (8.1), and Cloudflare MCP (7.7) round out the DevOps tier for teams using those platforms. Linear is listed with an explicit note that the Atlassian MCP is the right choice for Jira shops.

Part 5: Security Tooling — The Layer That Actually Ships to Production

Security is the area where the gap between "I have a plugin installed" and "I have security coverage" is widest. Three tools in this stack are doing meaningfully different things.

lasso-security/claude-hooks (score: 8.2, 160 stars) provides 50+ injection pattern detectors running at the PostToolUse hook lifecycle event. That timing matters: it catches malicious or unsafe outputs after a tool runs, before Claude Code acts on them.

Dippy (score: 7.8, 111 stars) takes a different approach: AST-based analysis of bash commands across 34 CLI handlers including git, kubectl, docker, terraform, helm, and gcloud. It's an auto-approver that understands the semantic structure of shell commands rather than just pattern-matching strings. Zero external dependencies.

Container Use by Dagger (score: 8.4, 3,700 stars) provides the strongest isolation model in the stack: one container per agent task, one git branch per run. If an agent task goes wrong, its blast radius is contained to the branch and the container. For teams running multi-hour autonomous workloads, this is table stakes.

"One container per agent task, one git branch per run — that's not a convenience feature. That's a production isolation model."

Trail of Bits Security Skills (score: 7.2) provides 12+ audit and vulnerability analysis skills. The recommended usage pattern is explicit: run these before any security-sensitive PR, not as continuous background scanning.

Part 6: Orchestration — When One Agent Isn't Enough

The orchestration tier is where Claude Code moves from a development assistant into a production autonomous system. Two tools define this space.

Claude Squad (score: 9.0, 6,500 stars) runs parallel agents in isolated git worktrees with a TUI dashboard for monitoring. The worktree isolation model means parallel agents can't step on each other's changes. The dashboard means you can see what all of them are doing simultaneously. For any task that can be parallelized — running multiple test suites, implementing multiple features, exploring multiple approaches — Claude Squad is the right tool.

ralph-orchestrator (score: 8.1, 2,200 stars) handles the sequential autonomous case: multi-backend loops with backpressure gates on test, lint, and type checking. Where ralph-wiggum (the official plugin) handles quick autonomous loops, ralph-orchestrator is designed for multi-hour runs with real validation gates between steps.

Note: These two tools complement rather than duplicate each other. Wiggum for quick loops. Orchestrator for multi-hour runs. Squad for parallel work. They cover three distinct orchestration shapes.

Part 7: Session Management and Monitoring — The Hidden Performance Layer

Session management is the most underestimated performance lever in the Claude Code stack. Long DevOps runs accumulate massive context windows. Without compression, you're paying token costs on session history that Claude could summarize once and discard.

context-mode MCP reduces session context from 315KB to 5.4KB — a 98% compression ratio. For long autonomous runs, this is not optional. The token economics of multi-hour workloads become untenable without it.

ccflare (score: 8.5, 910 stars) provides load balancing across multiple Claude accounts plus request-level analytics. Teams hitting rate limits on single accounts use ccflare to distribute load. The analytics dashboard surfaces per-request cost and latency.

claude-mem (score: 8.9, 38.9K stars) provides persistent memory across sessions using SQLite and Chroma as the backing store. Claude Code has no memory between sessions by default. Claude-mem changes that, maintaining a persistent knowledge base of what you've worked on, what decisions were made, and why.

Vibe-Log (score: 7.3, 306 stars) handles session productivity analytics and generates HTML retrospective reports. It's the tool for teams that want to understand what their Claude Code sessions actually accomplished — and where time and tokens went.

• https://github.com/tirth8205/code-review-graph
• https://github.com/anthropics/claude-plugins-official/tree/main/plugins

Conclusion: Fragmentation Is the Real Risk

This stack represents roughly 31 tools across 6 tiers. That's a lot of moving pieces — and the number is growing. The Claude Code ecosystem has accumulated 200+ community extensions in a short period, with no central quality signal, no compatibility guarantees, and no standard for what "maintained" means.

The tools that rise to the top of this stack — context7, Claude Squad, Container Use, ccusage — share a common trait: they solve discrete, well-understood engineering problems with clear interfaces. They don't try to be everything. They do one thing and expose it cleanly.