MCP Servers & Skills for Coding

Learning Objectives

• Explain how MCP servers extend the capability of AI coding tools beyond code generation
• Identify the most valuable MCP servers for common development workflows
• Create effective AGENTS.md and SKILL.md files that make AI agents productive from the first session

Beyond Code Generation

An AI coding tool without MCP is a very smart autocomplete: it can generate code snippets based on what you describe, but it can't read your actual codebase at scale, run your tests, query your database, or push code to GitHub.

MCP servers change this. When a coding agent has the right MCP servers configured, it becomes a genuine engineering collaborator — one that can:

• Read your entire repository and understand its structure
• Run your test suite and iterate until tests pass
• Query your production database to understand what data looks like
• Create a GitHub branch, commit changes, and open a pull request
• Deploy to your staging environment and check the deployment logs

The gap between "AI that helps you write code" and "AI that ships code" is largely bridged by MCP.

The ecosystem has grown explosively: over 10,000 MCP servers are now indexed on GitHub and directories like PulseMCP. The official MCP Registry (registry.modelcontextprotocol.io) hosts 518+ verified servers. Docker launched an MCP Catalog with 300+ servers packaged as container images — making installation as simple as docker pull. MCP is now governed by the Agentic AI Foundation (AAIF) under the Linux Foundation, backed by AWS, Anthropic, Google, Microsoft, OpenAI, and dozens more.

Essential MCP Servers for Development

File System and Codebase

The most fundamental MCP server gives your AI agent full read/write access to your file system — beyond what your IDE natively exposes. With file system MCP:

• The agent reads any file in your project, not just the ones currently open
• It writes files directly, rather than producing text you have to copy and paste
• It creates and deletes files as part of implementing a task

Many coding agents (Claude Code, Cursor in Agent mode) have native file system access without requiring a separate MCP server. But for agents accessed via API or CLI, file system MCP is foundational.

GitHub MCP

The GitHub MCP server connects your coding agent to your version control workflow. Major 2026 updates include Projects management tools, secret scanning (scans code for exposed secrets before commit), OAuth scope filtering (auto-detects your PAT permissions and hides unauthorized tools), and CI/CD workflow intelligence (monitor Actions runs, analyze build failures).

Available tools:
- list_repos, search_repos
- read_file, list_files
- create_branch, checkout_branch
- create_commit, push_branch
- create_pull_request, add_pr_comment
- list_issues, read_issue, create_issue
- projects_list, projects_get (NEW — 50% token reduction)
- secret_scanning (NEW — detects exposed credentials)

With GitHub MCP, an agent can receive a task description, read the relevant issue context, create a branch, implement the fix, run through its reasoning, and open a PR — the complete development loop, without leaving the agent interface.

Database MCP (Postgres / Supabase / SQLite)

Database MCP servers allow your agent to query your database directly:

Available tools:
- execute_sql
- list_tables
- get_schema
- explain_query

Practical impact: an agent writing a new feature can inspect your actual database schema — real column names, types, relationships — instead of guessing or requiring you to paste in a schema definition. Code it generates references the real column names and avoids type mismatches.

For Supabase specifically, the Supabase MCP server (v0.7.0) now uses OAuth authentication by default (no more Personal Access Tokens required), supports project scoping for security, and offers 20+ tools covering database, auth, storage, edge functions, branching, and debugging — making it possible to manage the entire backend from within an agent session.

Vercel MCP

For teams deploying to Vercel, the Vercel MCP server enables:

• Triggering deployments from the agent session
• Reading deployment logs to debug build failures
• Managing environment variables without leaving the terminal
• Checking domain configuration and SSL status

Useful pattern: agent implements a change, deploys it to the preview environment, reads the deployment logs to verify it succeeded, and reports the preview URL.

Playwright MCP

Browser automation MCP enables end-to-end testing and web interaction from within an agent session. Major 2026 improvements include a token-efficient CLI mode (27K tokens vs 114K via standard MCP — a 4x reduction), simplified session management, 143 device profiles (iPhone, iPad, Pixel, Galaxy, Desktop), and auto-configuration for GitHub Copilot's Coding Agent. The agent can:

• Navigate to your locally running application
• Interact with UI elements (click, type, select)
• Assert on page content and visual state via accessibility-tree-first execution
• Capture screenshots to verify rendering
• Run across 143 device profiles for responsive testing

This closes the loop between code generation and UI testing — the agent can implement a UI feature and immediately test it in a browser.

Docker, Kubernetes, and Beyond

The MCP ecosystem now extends well beyond the essentials above. Notable additions for developers:

• Docker MCP Catalog — 300+ verified, signed servers distributed via Docker Hub; custom organization catalogs for enterprise teams
• Kubernetes MCP — Multi-cluster management, pod inspection, log reading; read-only mode for production safety
• Context7 — The most popular MCP server by installs; provides up-to-date library documentation so agents use current APIs, not outdated training data
• Figma MCP (March 2026) — Generate design layers directly from VS Code; design-to-code workflows
• GitLab MCP — CI/CD pipelines, merge requests, issue tracking for GitLab teams

AGENTS.md — The Universal Agent Brief

Every AI coding session that starts from zero wastes time. The agent re-discovers your tech stack, re-learns your conventions, makes assumptions that don't match your decisions. AGENTS.md eliminates this waste.

AGENTS.md is now an official project under the Agentic AI Foundation (AAIF) at the Linux Foundation — donated by OpenAI alongside MCP. It is the emerging universal standard for project context files, supported by virtually all major AI coding tools as of early 2026. Think of it as: "README is for humans, AGENTS.md is the universal agent brief."

An AGENTS.md file in your project root is a structured document that gives any AI coding agent the context a senior developer would need to work effectively in your project from day one.

A well-structured AGENTS.md includes:

# Project Name

## What This Is
Brief description of the project and its purpose.

## Tech Stack
- Frontend: Next.js 15 (App Router), TypeScript, Tailwind CSS
- Backend: Supabase (PostgreSQL), Supabase Auth
- Payments: Stripe
- Deployment: Vercel

## Running the Project
- Dev server: `npm run dev` (localhost:3000)
- Tests: `npm test` (Playwright, runs against local server)
- Type check: `npm run type-check`

## Key Conventions
- All API routes in `app/api/` — use route.ts
- All MDX content in `content/module-{slug}/`
- Database calls only in Server Components or Server Actions
- Never import server code in client components
- Use `createClient()` from `lib/supabase/server.ts` — not custom client creation

## Files to Never Modify
- `supabase/schema.sql` — generated; edit via migrations
- `public/` — static assets; do not delete existing files

## Common Tasks
- Adding a new lesson: create MDX in `content/module-{slug}/`, run `npm run index-content`
- Adding a database table: apply migration via Supabase MCP, update schema.sql

AGENTS.md is supported by Claude Code, OpenAI Codex, GitHub Copilot, Cursor, Windsurf, Gemini CLI, and most other AI coding tools. Some tools also read their own tool-specific files (e.g., CLAUDE.md for Claude Code, .cursorrules for Cursor, .github/copilot-instructions.md for Copilot), but AGENTS.md is the universal standard that works across all of them. When an agent reads it at the start of a session, it immediately has the context that would otherwise take 15 minutes of back-and-forth to establish.

SKILL.md — Reusable Task Recipes

While AGENTS.md gives global project context, SKILL.md files teach an agent how to perform a specific recurring task in your project's specific way.

Think of a SKILL.md as a recipe: "here's exactly how to do X in this project, step by step, with the commands, file paths, and checks required."

Example: a SKILL.md for "add a new database table" in a Supabase project:

# Skill: Add New Database Table

## Steps
1. Write the SQL migration in plain SQL
2. Apply via Supabase MCP: `execute_sql` with the DDL
3. Update `supabase/schema.sql`:
   - Run: query pg_catalog to extract the updated schema
   - Commit the updated file to git
4. Generate TypeScript types: `supabase gen types typescript`
5. Add RLS policies for the new table (security default: deny all)
6. Update `lib/supabase/types.ts` with the generated types

## Naming Conventions
- Table names: snake_case, plural (e.g., `user_bookmarks`)
- Primary key: always `id uuid DEFAULT gen_random_uuid()`
- Timestamps: `created_at timestamptz DEFAULT now()`

When you invoke this skill in Claude Code with /add-database-table, the agent follows the exact workflow your project requires — not a generic approach that might not fit your tooling.

SKILL.md files scale especially well for tasks that happen frequently but require multiple steps: adding API routes, creating UI components following your design system, running the full deployment workflow.

Putting It Together

The combination of the right MCP servers, a well-written AGENTS.md, and relevant SKILL.md files transforms AI coding from a "help me think" tool into a "do this for me" tool.

A well-configured development environment in 2026:

1. Claude Code (or Cursor/Windsurf in agent mode) as the AI layer
2. File system + GitHub + Supabase + Vercel MCP servers connected
3. AGENTS.md in the project root documenting conventions and workflows
4. SKILL.md files for the 5-10 most common task types in the project

With this setup, many engineering tasks can be delegated to the agent entirely: "add a notes feature to the lesson page" → agent reads AGENTS.md, understands the stack, checks the GitHub issue for requirements, writes the database migration, updates types, creates the UI component, adds the API route, runs tests, commits, and opens a PR.

Key Takeaways

• MCP servers bridge the gap between "AI that helps write code" and "AI that ships code" — connecting agents to your file system, GitHub, databases, deployment platform, and testing infrastructure; the ecosystem has grown to 10,000+ servers with Docker distribution and an official registry
• The most valuable MCP servers for development: file system, GitHub (now with secret scanning and CI/CD intelligence), database (Supabase MCP v0.7.0 with OAuth), Vercel, Playwright (4x more token-efficient), Docker, and Kubernetes
• AGENTS.md is now a Linux Foundation/AAIF standard — the universal project context file supported by all major AI coding tools; invest 45 minutes in writing one and every agent session benefits
• MCP security is a real concern (OWASP MCP Top 10, 30+ CVEs in early 2026) — treat tool arguments as untrusted input and apply least-privilege permissions