The MCP Servers and Agent Skills That Developers Actually Use With Claude Code and Codex

If you've been running Claude Code or Codex CLI for more than a few sessions, you've probably hit the ceiling of what a raw agent can do. It hallucinates library APIs that changed six months ago. It can't see your live app. It doesn't know what your Sentry alerts say. It treats your codebase like it exists in a vacuum.

MCP servers and agent skills are how you fix that. As of March 2026, the ecosystem has matured enough that developers have clear opinions on what actually moves the needle — and what's noise. Here's what's winning in production.

The Two Layers: MCP vs. Skills

Before the list: these are different things.

MCP servers are long-running processes that give your agent access to external systems — GitHub, databases, browser automation, error monitoring. They're client-agnostic: one server config works with Claude Code, Codex CLI, Cursor, Windsurf, and any other compliant host. You wire them up in a JSON config and the agent calls them like tools.

Agent skills (SKILL.md files) are playbooks — specialized instructions, templates, and context that teach the agent how to approach a category of task. Since Anthropic standardized the format in late 2025, the same skill files work across Claude Code, Codex CLI, Cursor, and Gemini CLI. Skills are for encoding your engineering methodology; MCP servers are for connecting your stack.

The best setups use both. Here's what developers are actually reaching for.

MCP Servers: What's Actually Being Used

🥇 Context7 — The Breakout Hit

50,000+ GitHub stars as of March 2026. Context7 (upstash/context7) solves the most frustrating problem in agentic coding: your agent confidently generates code using APIs that changed eight months ago, because its training data is stale.

Context7 fetches live, version-specific documentation directly from source repositories and injects it into your agent's context on demand. When you're building with React 19, Next.js 15, or any rapidly evolving framework, the agent uses current docs — not whatever was in the training corpus.

claude mcp add context7 -- npx -y @upstash/context7-mcp

The pattern that developers report works best: pair Context7 with explicit version pins in your CLAUDE.md so the agent always pulls docs for the version you're actually running.

🥈 GitHub MCP — Beyond What gh CLI Does

GitHub's official MCP server is one of the most-installed, but it's worth being precise about where it earns its keep. For basic PR and issue operations, gh CLI is more token-efficient and still the right choice.

Where GitHub MCP wins: GitHub Actions CI/CD logs. When a build fails, the agent can pull the full Actions log, identify the failing step, cross-reference it with the codebase, and propose a fix — without you copy-pasting anything. That loop (fail → fetch → analyze → fix) is where the MCP format pays off over CLI wrappers.

claude mcp add --transport http github https://api.githubcopilot.com/mcp \
  -H "Authorization: Bearer YOUR_GITHUB_PAT"

🥉 Playwright MCP — The Agent Gets Eyes

Microsoft's Playwright MCP server remains one of the highest-value integrations in production workflows. The key capability: it navigates sites like a human — not via fetch requests or curl — meaning it processes live, rendered DOM rather than raw HTML.

The primary use case developers cite: writing tests against the actual running app. Instead of the agent inferring UI structure from source code, it can inspect the live rendered state, generate tests that match real behavior, and verify them end-to-end. It's also how agents handle form fills, dashboard interactions, and post-deploy verification.

claude mcp add playwright npx @playwright/mcp@latest

Sequential Thinking — Structured Reasoning for Complex Refactors

The official Sequential Thinking MCP server from the MCP reference implementations enables dynamic, reflective problem-solving through explicit thought sequences. For complex tasks — multi-file refactors, architectural changes, debugging production issues — it makes the agent's planning visible and structured rather than opaque.

Developers combine this with GitHub MCP for the debugging loop: sequential thinking to plan the investigation, GitHub MCP to fetch CI logs and history, then back to sequential thinking to structure the fix.

Stack-Specific Winners

Project Management & Ticketing: Jira and Azure DevOps

One of the most-requested integration categories for agentic coding workflows: connecting agents to your project tracking tools so they can read ticket requirements, pull acceptance criteria, and close work items autonomously as code ships. Two servers cover the major enterprise stacks.

Jira MCP — Atlassian Remote MCP Server

Atlassian now ships an official remote MCP server (under their Rovo AI platform) that connects Jira, Confluence, and the broader Atlassian suite to any MCP-compatible AI client. The setup is zero-infrastructure: point your MCP config at the remote endpoint and authenticate with your Atlassian account.

What agents can do with it: search for issues by JQL, fetch full ticket details including description, acceptance criteria, and comments, update issue status and fields, and pull information from linked Confluence pages. The practical workflow that teams report: agent reads the Jira ticket before starting a feature branch, extracts requirements from the description and linked design docs in Confluence, then marks the issue "In Review" when it opens the PR.

claude mcp add --transport sse atlassian https://mcp.atlassian.com/v1/sse

For teams using Jira Cloud, this is the recommended path. For self-hosted Jira or teams that want a more targeted integration (just ticket context for the coding agent, nothing else), the community Jira-Context-MCP is worth evaluating — it's specifically designed to feed ticket details into coding agents like Cursor and Claude Code:

npx -y @smithery/cli install @rahulthedevil/Jira-Context-MCP --client claude

Azure DevOps MCP — Microsoft Official

Microsoft's official Azure DevOps MCP server (microsoft/azure-devops-mcp) is the most comprehensive integration for ADO shops. It covers the full DevOps surface: work items, boards, sprint iterations, repos, pipelines, and test plans — all accessible from your coding agent.

The remote MCP Server is now in public preview for all organizations, which means no local process to manage. Add the endpoint to your MCP config, authenticate via Microsoft Entra, and agents can query sprint status, summarize open PRs, create work items, and inspect pipeline failures in one session.

# Local stdio (stable, any MCP client)
claude mcp add ado -- npx -y @azure-devops/mcp YOUR_ORG_NAME

# Remote (public preview, no local install)
# Add https://ado.mcp.microsoft.com to your MCP config with Entra auth

The canonical use case: agent is given a work item ID, fetches the full story details and acceptance criteria, implements the feature, updates the work item status to "Done", and links the PR back to the item — all without human clipboard work. For teams running Azure Pipelines, the pipeline log access closes the same CI/CD debugging loop that GitHub MCP provides for GitHub Actions users.

Note on Linear vs. Jira vs. ADO: Linear MCP remains the right choice for smaller engineering teams on modern tooling — it's simpler and faster. Jira and Azure DevOps MCPs are for enterprise environments where the tool choice isn't up for debate. Pick based on what your team already runs.

Agent Skills: What's Actually Installed

frontend-design — 277,000+ Installs

The most-installed official Anthropic skill, and it addresses something fundamental: without guidance, LLMs converge on the same design decisions — Inter font, purple gradient, grid cards. Anthropic calls it "distributional convergence." The model reproduces the statistical center of its training data.

The frontend-design skill injects a design system and philosophy before the agent touches code — bold aesthetic choices, distinctive typography, purposeful color palettes. The result is components that look like a designer reviewed them rather than a pattern-matching system generated them. For any team shipping user-facing applications, this is table stakes.

webapp-testing — Playwright as a Skill

Note the overlap with the Playwright MCP server. The skill version encodes how to write Playwright tests — the methodology, patterns, and verification loops. The MCP provides the live browser. You can use either, but teams doing serious UI test automation often use both: the skill for the approach, the MCP for live interaction.

mcp-builder — The Meta Skill

The mcp-builder skill guides Claude through creating new MCP servers that integrate external APIs and services. Given how fast the ecosystem moves, the ability to build a custom MCP in a session rather than waiting for an official server has become genuinely useful. It follows best practices for tool schema design, error handling, and auth patterns.

Superpowers (Third-Party)

One of the most-mentioned third-party skills: a structured lifecycle framework covering brainstorming → TDD → debugging → code review. Rather than ad-hoc prompting through a feature, Superpowers enforces a discipline — the agent follows defined stages with explicit handoffs. Teams report fewer "agent went off-track" situations when the methodology is encoded in the skill rather than relied upon in the prompt.

browser-use

Addresses what Playwright MCP doesn't handle alone: the agent actually using a browser as part of a workflow — filling forms, logging into dashboards, navigating authenticated states. Where Playwright MCP is primarily for testing and inspection, browser-use skills encode interaction patterns for live web automation tasks.

The Engineering Pattern That's Emerging

The setups that consistently outperform raw agents share a structure:

1. Context layer: Context7 for live docs + CLAUDE.md/AGENTS.md for project-specific context
2. Execution layer: Playwright MCP or Desktop Commander for live system interaction
3. Observability layer: Sentry + GitHub MCP (or Azure DevOps MCP) for production feedback loops
4. Project layer: Jira, Azure DevOps, or Linear MCP for ticket-to-code-to-close workflows
5. Methodology layer: Skills for encoding how the team wants the agent to approach specific task classes

The agents that struggle are the ones thrown at a codebase with nothing but a system prompt and good intentions. The agents that ship reliably have all five layers wired up.

What to Actually Install First

If you're starting from scratch, the three-server baseline that works across almost every stack:

1. Context7 — zero config, no API key required, immediately reduces hallucinated API calls
2. GitHub MCP — CI/CD log access closes the build-fail debugging loop
3. Playwright MCP — Microsoft-maintained, actively developed, handles live app verification

Add Sentry, Supabase, or Linear based on your stack. Add Jira or Azure DevOps MCP if your team runs enterprise project tooling and wants agents that can read tickets and close them autonomously. Add skills based on your engineering methodology. The rest follows from what you're actually building.

The ecosystem will keep growing — there are thousands of MCP servers now, with new ones shipping weekly. But the core pattern is stable: give the agent current knowledge, system access, production feedback, and a direct line to your project tracker. Everything else is stack-specific configuration.