AI Coding Agent Setup Reference

A curated, reusable catalog for configuring and extending AI coding agents — MCP servers, Skills, Subagents, Slash Commands, Hooks, Plugins, Rules, and memory files — across Claude Code, Cursor, Codex, Windsurf, and the rest. Pull from this any time you stand up a new machine, repo, or product so you never re-research the ecosystem.

0. The Mental Model — 6 Configuration Layers

Every modern agent (Claude Code, Cursor, Codex, Windsurf, Cline…) is configured through some combination of these six layers. Learn the layers once; the per-tool syntax is just dialect.

Layer	What it is	When it loads	Analogy
1. Memory / Custom Instructions	Always-on project context (`CLAUDE.md`, `AGENTS.md`, Cursor “Rules for AI”)	Every message	The agent’s constitution
2. Rules	Conditional instructions scoped by file/glob/description (Cursor `.mdc`)	When their scope matches	Style guide that opens to the right page
3. Skills	On-demand expertise packets (`SKILL.md` + scripts)	When the task matches the description	A specialist you call in
4. MCP Servers	External tool/data access (GitHub, DB, browser, APIs)	When the agent needs to act on something	The agent’s hands
5. Subagents	Isolated agents for parallel/heavy work	When delegated to	Junior teammates
6. Hooks	Code that fires automatically on events (pre/post tool use)	On the triggering event	Reflexes / quality gates
(+) Plugins	Bundles of the above, shared with one install	On install	The whole toolbox, packaged

Rule of thumb: Memory tells it how to think → Rules refine that conditionally → Skills give repeatable expertise → MCP gives it hands → Subagents parallelize → Hooks enforce → Plugins package it all to share.

1. Cross-Client Config File Map

Where each layer physically lives, per tool. Bookmark this table — it’s the thing you’ll actually look up.

Layer	Claude Code	Cursor	Codex CLI	Claude Desktop
Memory	`CLAUDE.md` (project), `~/.claude/CLAUDE.md` (global), `CLAUDE.local.md`	`.cursor/rules/` + `AGENTS.md`	`AGENTS.md` (walks root→cwd)	—
Rules	(use CLAUDE.md / skills)	`.cursor/rules/*.mdc`	`AGENTS.md` per-folder	—
Skills	`.claude/skills/` (project), `~/.claude/skills/` (user)	`.agents/skills/` / via marketplace	`.agents/skills/` (project), `~/.codex/skills/` (user)	Uploaded in UI / API
MCP	`.mcp.json` (project) or `claude mcp add`	`.cursor/mcp.json` (project), `~/.cursor/mcp.json` (global)	`[mcp_servers]` in `~/.codex/config.toml` or `codex mcp add`	`claude_desktop_config.json` + Connectors UI
Subagents	`.claude/agents/*.md`	(agent mode)	`[agents]` in `config.toml`	—
Commands	`.claude/commands/*.md` (now unified w/ skills)	(chat)	(skills)	—
Hooks	`settings.json` hooks block	Cursor Hooks	`hooks.json` / `[hooks]` in `config.toml`	—
Plugins	`/plugin` + marketplaces	Marketplace	`codex` plugin marketplaces	Connectors
Settings	`~/.claude/settings.json`	Settings UI / `.cursor/`	`~/.codex/config.toml`	App settings

The convergence: AGENTS.md (memory) and SKILL.md (skills) are becoming cross-tool standards — write once, most agents read them. MCP is universal. The tool-specific bits are mostly rules format and settings location.

2. MCP (Model Context Protocol)

The USB-C port for AI — one open standard so any compliant client can plug into any compliant server. Created by Anthropic (Nov 2024), donated to the Linux Foundation’s Agentic AI Foundation in Dec 2025 (vendor-neutral now). ~10K servers in the official registry as of mid-2026.

Core concepts

Host = the AI app (Claude Code, Cursor, Codex, Claude Desktop, ChatGPT).
Server = the integration (GitHub, Postgres, browser…). One client per server.
Transports: stdio (local process, fastest for local tools) and Streamable HTTP (remote servers; replaced the old SSE transport). Pick stdio for local dev tools, HTTP for hosted/team services.
Primitives: Tools (actions), Resources (data), Prompts (templates).

Official resources

Resource	URL
Spec & docs	https://modelcontextprotocol.io/
Official registry (“app store”)	https://github.com/modelcontextprotocol/registry
Reference servers repo	https://github.com/modelcontextprotocol/servers
MCP Inspector (debug/test servers)	https://github.com/modelcontextprotocol/inspector
Spec blog (roadmap, releases)	https://blog.modelcontextprotocol.io/

Official reference servers (the maintained core set)

Install pattern: npx -y @modelcontextprotocol/server-<name>.

Server	Purpose
Filesystem	Scoped read/write to local files
Git	Local repo operations
Fetch	Fetch + convert web content for the model
Memory	Persistent knowledge-graph memory
Sequential Thinking	Structured multi-step reasoning
Time	Time/timezone utilities
Everything	Reference/test server exercising all primitives

Note: many early reference servers (GitHub, Slack, Postgres, Puppeteer, GDrive) graduated into vendor-maintained official servers in their own repos — see below.

High-value production servers (your stack)

Server	What it does	Where
GitHub	PRs, issues, repo mgmt beyond git	https://github.com/github/github-mcp-server
Playwright	Drive/inspect a real browser (your shared Chrome-profile setup)	https://github.com/microsoft/playwright-mcp
Chrome DevTools	Control + inspect Chrome	(official, via registry)
Context7	Up-to-date library/framework docs injected on demand	https://github.com/upstash/context7
Supabase	Manage DB/auth/storage	https://github.com/supabase-community/supabase-mcp
PostgreSQL	Query/inspect schemas	via registry (multiple impls)
Sentry	Pull error/trace context	https://docs.sentry.io/product/sentry-mcp/
Figma	Read designs into the agent	https://www.figma.com/ (Dev Mode MCP)
Notion	Read/write workspace	https://github.com/makenotion/notion-mcp-server
Stripe	Payments ops	https://github.com/stripe/agent-toolkit
Vercel	Deploy/inspect projects	https://vercel.com/docs/mcp
Cloudflare	Workers/KV/R2/D1	https://github.com/cloudflare/mcp-server-cloudflare
Exa / Perplexity	Web search for agents	https://github.com/exa-labs/exa-mcp-server

MCP discovery directories (where to find servers)

Directory	Note	URL
Official Registry	Canonical, community-governed	https://registry.modelcontextprotocol.io/
Smithery	Largest installer/registry, one-click client config	https://smithery.ai/
Glama	Browsable server catalog	https://glama.ai/mcp/servers
PulseMCP	News + directory, updated frequently	https://www.pulsemcp.com/
mcp.so	Community directory	https://mcp.so/
awesome-mcp-servers (appcypher)	Curated list	https://github.com/appcypher/awesome-mcp-servers
awesome-mcp (abordage)	Auto-updated daily	https://github.com/abordage/awesome-mcp

Adding an MCP server (per client)

# Claude Code — local stdio server
claude mcp add github -- npx -y @modelcontextprotocol/server-filesystem ~/code
# Claude Code — remote HTTP server
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp

# Codex CLI
codex mcp add github -- npx -y @github/github-mcp-server
#   (or edit [mcp_servers] in ~/.codex/config.toml)

# Cursor — edit .cursor/mcp.json (or use the Marketplace UI)

{
  "mcpServers": {
    "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp"] },
    "supabase": { "command": "npx", "args": ["-y", "@supabase/mcp-server-supabase"] }
  }
}

⚠️ Security: an MCP server runs with your credentials and can read/write whatever you scope it to. Read the source before connecting anything to a host that has your tokens. Matters doubly for your pharma/SOC 2 work — keep prod-credentialed servers off shared/experimental hosts.

3. Skills (Agent Skills)

Folders of instructions + scripts + resources that the agent loads only when the task matches — keeping the context window clean until needed. Now a cross-tool standard (works in Claude Code, Cursor, Codex, Copilot, Goose, Claude.ai, API…).

Official resources

Resource	URL
Anthropic Skills repo (official examples + skill-creator)	https://github.com/anthropics/skills
Agent Skills standard (cross-tool spec)	https://agentskills.io/
Claude Code skills docs	https://code.claude.com/docs/en/skills
Skills API quickstart	https://docs.claude.com/en/docs/agents-and-tools/agent-skills
`ai-agent-skills` universal installer (npx)	`npx ai-agent-skills install <skill> --agent <agent>`

Anatomy

A skill is just a folder with a SKILL.md (YAML frontmatter + Markdown body):

---
name: my-skill
description: What it does AND when to use it. Be a little "pushy" — Claude
  under-triggers skills. e.g. "Use whenever the user mentions X, Y, or Z,
  even if they don't say 'skill'."
# optional: disable-model-invocation: true  (manual-only)
# optional: context: fork  (run in a subagent to protect main context)
---

Step-by-step instructions. Keep this lean; push examples/edge-cases/templates
into sibling files the agent pulls in only when relevant.

Creating skills

skill-creator — Anthropic’s official skill that scaffolds a new skill (structure, SKILL.md, validation, optional PR + local download). It’s in anthropics/skills and ships in Claude.ai. Just say “use skill-creator to build a skill for X.” https://github.com/anthropics/skills/tree/main/skills/skill-creator
mcp-builder — companion skill that scaffolds an MCP server (Python FastMCP or TS SDK).
Description-writing is the #1 lever: skills mostly fail by under-triggering. Front-load the use case, name concrete trigger phrases, and be slightly pushy.

Skill directories / where to find them

Source	URL
anthropics/skills (official)	https://github.com/anthropics/skills
awesome-claude-code (skills, hooks, commands, agents)	https://github.com/hesreallyhim/awesome-claude-code
Smithery (skills section)	https://smithery.ai/

Installing

# Universal installer (auto-routes to the right folder for your agent)
npx ai-agent-skills install frontend-design --agent claude-code
npx ai-agent-skills install anthropics/skills/pdf

# Claude Code — register the official repo as a plugin marketplace
/plugin marketplace add anthropics/skills
/plugin install document-skills@anthropic-agent-skills

4. Subagents

Isolated agent instances for parallel work and context protection — searching files, scanning logs, deep research — so the main session stays focused. You can assign cheaper/faster models to grunt-work subagents.

Tool	Where	How
Claude Code	`.claude/agents/*.md` (YAML frontmatter: `name`, `description`, optional `model`, `tools`)	`/agents` to create interactively; invoke by name or natural language
Codex	`[agents]` table in `config.toml` (+ per-agent `config_file`)	role-based; see Codex Subagents docs
Cursor	Agent mode / background agents	UI

---
name: code-reviewer
description: Reviews diffs for bugs, security, and maintainability.
model: claude-haiku-4-5   # cheaper model for grunt work
---
You read code diffs and report issues. Focus on correctness and security.

Pattern that works: a slash command (or skill) invokes a subagent for planning, then the main agent handles execution — structured workflow + full tool access.

5. Slash Commands

User-initiated shortcuts (/command) — saved prompts/workflows, per-project or global. In recent Claude Code, custom commands have merged into skills (a SKILL.md is callable as /skill-name), but the .claude/commands/ folder still works.

Tool	Where
Claude Code	`.claude/commands/.md` (project), `~/.claude/commands/.md` (user) — or just use skills
Codex	via skills
Built-ins	`/help`, `/clear`, `/model`, `/agents`, `/plugin`, `/doctor`, `/team-onboarding` (Claude Code)

6. Hooks

Code that fires automatically on events — invisible, deterministic enforcement. Run Prettier before an edit is accepted, run typecheck after, block a dangerous command, send a desktop notification when a task finishes. ~24 hook events in Claude Code.

Tool	Where	Events (examples)
Claude Code	`hooks` block in `settings.json`	`PreToolUse`, `PostToolUse`, `Notification`, `Stop`, `SubagentStop`
Codex	`hooks.json` or `[hooks]` in `config.toml` (project hooks load only if trusted)	command hooks (pre/post)
Cursor	Cursor Hooks	lifecycle events

Use hooks for quality gates (lint/typecheck/test) and guardrails (never commit without review, never rm -rf). Skills you invoke; hooks just run.

7. Plugins & Marketplaces

A plugin bundles commands + subagents + MCP servers + hooks + skills into a one-command install — the cleanest way to share a whole setup across repos/teammates.

Tool	How
Claude Code	`/plugin marketplace add <git-or-local>` then `/plugin install <name>@<marketplace>`
Codex	`codex` plugin marketplace commands (Git or local sources)
Cursor	Marketplace UI

Resource	URL
Claude Code plugins announcement	https://www.anthropic.com/news/claude-code-plugins
awesome-claude-code (plugins, marketplaces)	https://github.com/hesreallyhim/awesome-claude-code
anthropics/skills as a marketplace	https://github.com/anthropics/skills

Your ECC plugin (16 agents / 40 commands / 60+ skills) is exactly this pattern at scale. Your .zaj/ shared-skill protocol is your own private marketplace-in-waiting — packaging it as a real plugin marketplace would make it one-command-installable across every machine/repo.

8. Rules (Cursor-specific, but conceptually universal)

Persistent, conditionally-loaded instructions. Cursor moved from a single legacy .cursorrules file to the .cursor/rules/*.mdc directory for scope control + token efficiency (legacy file still read).

Four activation modes — choosing right is the whole game:

Mode	Loads when	Use for
Always Apply	every request	your stack declaration only
Auto Attached	a matching file glob is touched	language/framework rules (React, SQL…)
Agent Requested	the agent decides from the rule’s description	tool-specific (Supabase, Stripe…)
Manual	you type `@rule-name`	rarely-needed specialized rules

Token discipline: Cursor’s working context is ~20k tokens; bloated always-on rules eat your thinking space. Keep all-but-stack rules conditional; write dense, not wordy.

Resource	URL
cursor.directory (rules + MCP catalog)	https://cursor.directory/
awesome-cursorrules	https://github.com/PatrickJS/awesome-cursorrules
Cursor docs	https://docs.cursor.com/

9. Memory Files — `CLAUDE.md` / `AGENTS.md`

The always-on “constitution.” Keep it tight: build/lint/test commands, conventions, do’s and don’ts, project structure. Re-read every session so you never re-explain the project.

File	Read by
`CLAUDE.md`	Claude Code (project), `~/.claude/CLAUDE.md` (global), `CLAUDE.local.md` (untracked personal)
`AGENTS.md`	Codex, Cursor, and a growing list — the cross-tool standard; Codex walks repo-root → cwd concatenating them

Resource	URL
AGENTS.md standard	https://agents.md/
Anthropic memory/CLAUDE.md docs	https://code.claude.com/docs/en/memory

# AGENTS.md  (works in Codex, Cursor, and others)
## Build / Test
pnpm install · pnpm build · pnpm test
## Conventions
- TypeScript strict; no default exports
- Commit format: feat/fix/chore(scope): description
## Guardrails
- Never commit without review · Verify a package is installed before importing

Tip: maintain ONE AGENTS.md as the source of truth and symlink/point CLAUDE.md at it where you want Claude-specific additions — avoids drift across tools. (Fits your .zaj/ shared-protocol goal.)

10. The Clients — Quick Setup Reference

Client	Type	Config home	MCP	Skills	Memory	Notes
Claude Code	CLI + IDE + desktop + web + iOS	`~/.claude/`, `.claude/`	`claude mcp add` / `.mcp.json`	`.claude/skills/`	`CLAUDE.md`	Most mature ecosystem; Agent Teams (Feb 2026). Your primary.
Cursor	AI-first IDE (+ CLI, JetBrains plugin)	`.cursor/`	`.cursor/mcp.json` + Marketplace	marketplace / `.agents/skills`	`.cursor/rules` + `AGENTS.md`	Best inline editing; `.mdc` rules; Background Agent; `npm i -g @cursor/cli`. Your secondary.
Codex	CLI + VS Code ext + desktop	`~/.codex/config.toml`, `.codex/`	`[mcp_servers]` / `codex mcp add`	`~/.codex/skills/`, `.agents/skills/`	`AGENTS.md`	One config shared across all 3 surfaces; built-in web search; Node 22+. Can run as an MCP server.
Windsurf	AI IDE	`.windsurf/`	native MCP	rules	rules + `AGENTS.md`	Cascade agent; native MCP client.
Cline	Open-source VS Code agent	VS Code settings	MCP supported	—	rules	Strong open-source option.
Zed	GPU editor	settings	native MCP	—	—	Fast; native MCP client.
Antigravity	Gemini-based agent IDE	—	MCP	—	—	Google, public preview (you’ve evaluated).
Kiro	AWS spec-driven agent IDE	—	MCP	—	spec files	Spec-first workflow (you’ve evaluated).

Client docs	URL
Claude Code	https://code.claude.com/docs/
Cursor	https://docs.cursor.com/
Codex	https://developers.openai.com/codex/
Windsurf	https://docs.windsurf.com/
Cline	https://docs.cline.bot/
Zed	https://zed.dev/docs/

11. The Awesome Lists (Master Index)

The lists worth bookmarking — they update faster than any static doc.

List	Covers	URL
awesome-claude-code	Skills, hooks, commands, agents, plugins, orchestrators	https://github.com/hesreallyhim/awesome-claude-code
awesome-mcp-servers (appcypher)	MCP servers, all categories	https://github.com/appcypher/awesome-mcp-servers
awesome-mcp (abordage)	Servers + clients + frameworks, daily auto-update	https://github.com/abordage/awesome-mcp
awesome-cursorrules	Cursor rule templates by stack	https://github.com/PatrickJS/awesome-cursorrules
cursor.directory	Rules + MCP, browsable	https://cursor.directory/
anthropics/skills	Official skills + skill-creator + mcp-builder	https://github.com/anthropics/skills
Smithery	MCP servers + skills installer	https://smithery.ai/
MCP official registry	Canonical server registry	https://registry.modelcontextprotocol.io/

12. Recommended Zajaly Setup (Committed Baseline)

Opinionated, given your stack (Claude Code primary, Cursor secondary, the .zaj/ ecosystem, pharma + multi-SaaS work). Adopt this; tune later.

A. One source of truth for memory

Maintain a single AGENTS.md per repo (works in Cursor + Codex), and a thin CLAUDE.md that points to it with Claude-specific additions. Kills cross-tool drift — the exact pain .zaj/ is meant to solve.

B. Core MCP servers (install everywhere)

Context7 — current library docs on demand (stops the agent hallucinating old APIs; pairs with your “research modern libraries” prompter default).
Filesystem + Git — table stakes.
GitHub — PRs/issues without leaving the agent.
Playwright — your shared persistent Chrome-profile QA setup.
Supabase + Postgres — for Slidely/Pharmax/ClinPharm data work.
Sentry — once a product is in staging/prod.
Figma — when design-to-code is in play.

C. Skills discipline

Keep your zaj-* skills as the private core; package them as a Claude Code plugin marketplace so any machine gets them with /plugin install. That’s the upgrade path for .zaj/ shared-skill protocol.
Use skill-creator to author new ones (don’t hand-roll), and mcp-builder if you ever wrap an internal API as MCP.
Write pushy descriptions — under-triggering is the #1 skill failure.

D. Hooks (guardrails that matter for pharma/SOC 2)

PreToolUse: block destructive commands; require review before commit.
PostToolUse: run lint + typecheck on edited files.
Notification hook so long agent runs ping you (helps the ADHD fire-and-forget trap).

E. Rules (Cursor)

ONE always-on stack-declaration rule. Everything else Auto Attached (by glob) or Agent Requested (by description). Protect the ~20k context budget.

F. Security posture

Vet every MCP server’s source before giving it credentials. Keep prod-credentialed servers (Supabase prod, Stripe live) out of experimental/secondary clients — Claude Code project-scoped only, never a global config you forget about.

13. Things You Might Have Missed (Checklist)

☐ AGENTS.md is the cross-tool memory standard — write it once instead of maintaining separate Cursor rules + CLAUDE.md + Codex config. Symlink the rest at it.
☐ Skills are cross-tool now — your zaj-* skills aren’t Claude-Code-only; the same SKILL.md runs in Cursor/Codex via the Agent Skills standard.
☐ MCP SSE transport is deprecated — new remote servers use Streamable HTTP. Don’t copy old SSE config from 2024 tutorials.
☐ Skill descriptions are the whole ballgame — agents under-trigger; be pushy and name trigger phrases.
☐ Context budget is finite — every always-on rule / fat CLAUDE.md / unused MCP server is tax on the agent’s thinking space. Prune ruthlessly; make rules conditional.
☐ MCP servers run with your credentials — read the source; scope tightly; keep prod creds off shared hosts. (Your SOC 2 instinct applies here.)
☐ Plugins beat manual file-syncing — package .zaj/ as a marketplace so a new machine is one command, not an afternoon.
☐ Codex shares one config across CLI/VS Code/Desktop — if you want identical setup across surfaces, that’s its edge over Claude Code.
☐ MCP Inspector exists — debug a flaky server with npx @modelcontextprotocol/inspector instead of guessing.
☐ skill-creator and mcp-builder are official — don’t hand-build skills or MCP servers from scratch; scaffold them.
☐ MCP is now Linux Foundation-governed — it’s a durable bet, not a single-vendor gamble. Specific server names are snapshots; the protocol is permanent.

Maintained for the Zajaly AI-agent stack. Companion to Starlight-Awesome-List.md. Sourced from official MCP, Claude Code, Cursor, and Codex documentation plus the major community awesome-lists.

Metadata

Created: 2026-06-08
Version: v1.0
Verified current as of: June 2026 (MCP under Linux Foundation/AAIF; Claude Code Agent Teams; Cursor .mdc rules; Codex unified config)
Changelog:
- v1.0 (2026-06-08) — Initial compilation: 6-layer config model, cross-client file map, MCP (servers + directories + setup), Skills (standard + skill-creator), Subagents, Slash Commands, Hooks, Plugins, Cursor Rules, AGENTS.md/CLAUDE.md memory, client quick-reference, master awesome-list index, committed Zajaly baseline, missed-items checklist.

AI Coding Agent Setup Reference

0. The Mental Model — 6 Configuration Layers

1. Cross-Client Config File Map

2. MCP (Model Context Protocol)

Core concepts

Official resources

Official reference servers (the maintained core set)

High-value production servers (your stack)

MCP discovery directories (where to find servers)

Adding an MCP server (per client)

3. Skills (Agent Skills)

Official resources

Anatomy

Creating skills

Skill directories / where to find them

Installing

4. Subagents

5. Slash Commands

6. Hooks

7. Plugins & Marketplaces

8. Rules (Cursor-specific, but conceptually universal)

9. Memory Files — CLAUDE.md / AGENTS.md

10. The Clients — Quick Setup Reference

11. The Awesome Lists (Master Index)

12. Recommended Zajaly Setup (Committed Baseline)

13. Things You Might Have Missed (Checklist)

9. Memory Files — `CLAUDE.md` / `AGENTS.md`