Featured Anthropic Claude Code Developer Ecosystem Agent SDK MCP GitHub Actions Plugins Skills

The Complete Map of Anthropic's Developer Ecosystem: 22 Repos, One Vision

A deep dive into every public repository in the Anthropic GitHub org — how Claude Code, Agent SDKs, MCP servers, plugins, GitHub Actions, and learning resources all connect into one coherent developer platform.

February 25, 2026 • 15 min read • By Claude World

If you visit github.com/anthropics, you’ll find over 80 repositories. Most developers only know about one or two. But beneath the surface, there’s a carefully designed ecosystem where every piece connects to every other piece.

I spent time mapping every Claude-related repository in the Anthropic org. Here’s what I found: 22 repos that form 7 layers of a complete developer platform — from low-level API access to fully autonomous agents, from local CLI tools to CI/CD automation, from learning resources to production monitoring.

This article is the map I wish I had when I started.

The Architecture at a Glance

┌─────────────────────────────────────────────────────────┐
│  Layer 7: Learning & Onboarding                         │
│  courses → cookbooks → quickstarts → devcontainer       │
├─────────────────────────────────────────────────────────┤
│  Layer 6: Monitoring & Security                         │
│  monitoring-guide, security-review                      │
├─────────────────────────────────────────────────────────┤
│  Layer 5: CI/CD Automation                              │
│  claude-code-action, base-action                        │
├─────────────────────────────────────────────────────────┤
│  Layer 4: Plugins, Skills & Domain Extensions           │
│  plugins-official, skills, knowledge-work, financial    │
├─────────────────────────────────────────────────────────┤
│  Layer 3: MCP (Model Context Protocol)                  │
│  claude-ai-mcp, github-mcp-server                       │
├─────────────────────────────────────────────────────────┤
│  Layer 2: Agent SDKs (High-level)                       │
│  agent-sdk-python, agent-sdk-typescript, demos          │
├─────────────────────────────────────────────────────────┤
│  Layer 1: Foundation                                    │
│  anthropic-sdk-python/ts, claude-code, constitution,    │
│  anthropic-cli                                          │
└─────────────────────────────────────────────────────────┘

Let’s go layer by layer.

Layer 1: The Foundation

anthropic-sdk-python & anthropic-sdk-typescript

Everything starts here. These are the official REST API SDKs — the lowest-level way to talk to Claude.

from anthropic import Anthropic
client = Anthropic()
message = client.messages.create(
    model="claude-opus-4-6-20250219",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}]
)

What they provide: Messages API, streaming, tool use, message batches, token counting, file uploads, and support for AWS Bedrock and Google Vertex AI.

When to use: You’re building a product that calls Claude as a service — chatbots, classifiers, content pipelines, RAG systems.

claude-code

The flagship product. Claude Code is an agentic coding assistant that lives in your terminal. It doesn’t just answer questions — it reads your files, writes code, runs tests, manages git, and executes multi-step workflows.

Claude Code is also the runtime engine underneath the Agent SDKs. When you install the Agent SDK, it bundles Claude Code’s CLI. This is a crucial architectural decision: the SDKs don’t re-implement file operations and tool execution — they delegate to Claude Code.

claude-constitution

Released January 2026 under CC0 (public domain), the Constitution defines Claude’s values, decision-making framework, and behavioral boundaries. It’s not code — it’s the ethical operating system that every Claude model runs on.

Why it matters for developers: understanding the Constitution helps you predict how Claude will behave in edge cases. It explains why Claude sometimes refuses, how it weighs competing priorities, and what its “hard constraints” are.

anthropic-cli

Still under active development. This will be a developer-focused CLI for direct API interaction — complementary to Claude Code but focused on API operations rather than agentic coding.

Layer 2: Agent SDKs

claude-agent-sdk-python & claude-agent-sdk-typescript

Here’s where it gets interesting. The API SDKs let you call Claude. The Agent SDKs let you build with Claude Code’s full capabilities programmatically.

from claude_agent_sdk import query

async for message in query(
    prompt="Refactor the auth module to use JWT",
    options={"max_turns": 10}
):
    print(message)

Key difference from API SDKs:

AspectAPI SDKAgent SDK
AbstractionREST API wrapperAgent framework
File accessNoFull filesystem
Tool executionManual tool_use handlingBuilt-in (Bash, Read, Write, Edit)
Multi-stepYou orchestrateAgent plans and executes
Use caseAPI integrationAutonomous agents

The Agent SDK exposes three core APIs:

  1. query() — Fire-and-forget: give it a task, get back results
  2. ClaudeSDKClient — Stateful, bidirectional conversations
  3. create_sdk_mcp_server() — Define custom tools as Python/TS functions that Claude can call

claude-agent-sdk-demos

Six production-grade reference implementations:

  • Email Agent (TS + React) — Full IMAP assistant with AI search and custom actions
  • Research Agent (Python) — Multi-agent coordinator with parallel researcher subagents
  • Excel Demo (Electron) — Desktop spreadsheet manipulation
  • Resume Generator — DOCX file generation
  • Simple Chat App — Minimal getting-started UI
  • Hello World — The simplest possible agent

These aren’t toy examples. The Email Agent has SQLite integration, WebSocket communication, and UI state management. The Research Agent demonstrates the orchestrator-worker pattern that scales to real applications.

Layer 3: MCP (Model Context Protocol)

MCP is how Claude reaches out to the world. If the SDK is Claude’s brain, MCP is its hands.

github-mcp-server

GitHub’s official MCP server (written in Go), providing 50+ tools across 6 categories:

  • repos — Read files, branches, commits, search code
  • issues — Full CRUD on issues
  • pull_requests — Create, review, merge PRs, read diffs
  • users — User data lookup
  • code_security — Scanning alerts, secret detection
  • experiments — Beta features

This server is what powers Claude Code’s native GitHub integration. When you ask Claude to “create a PR for this change,” it’s calling these MCP tools under the hood.

claude-ai-mcp

Not an MCP server itself — it’s the issue tracker and communication hub for MCP integration in Claude.ai. If you’re building MCP servers and hit authentication issues, OAuth problems, or session management bugs, this is where you report them.

Layer 4: Plugins, Skills & Domain Extensions

This layer is where the ecosystem becomes truly extensible.

claude-plugins-official

The curated marketplace. 25 official plugins + 15 partner plugins, each following a standard structure:

my-plugin/
├── .claude-plugin/plugin.json   ← Metadata
├── .mcp.json                     ← MCP server configs
├── /commands/                    ← Slash commands
├── /skills/                      ← Domain knowledge
├── /agents/                      ← Specialized sub-agents
└── /hooks/                       ← Event automation

Notable plugins:

  • code-review — Multi-agent PR review
  • feature-dev — 7-phase feature development workflow
  • security-guidance — Security pattern detection
  • pr-review-toolkit — 6 specialized reviewer agents

Install with /plugin install plugin-name@claude-plugin-directory or browse in the UI.

skills

The Agent Skills specification and reference implementations. Skills are the simplest extension unit — just a markdown file with YAML frontmatter:

---
name: pdf-expert
description: Create, manipulate, and extract from PDFs
---
# Instructions for handling PDF files...

No code. No build steps. No infrastructure. Skills work across Claude Code, Claude.ai, and the Claude API. The repo includes 16 skill categories from brand guidelines to spreadsheet manipulation.

knowledge-work-plugins

11 role-based plugins that turn Claude into a domain expert:

  • productivity — Tasks, calendars, daily workflows
  • sales — Prospecting, pipeline, call prep
  • customer-support — Triage, draft responses, escalations
  • product-management — Specs, roadmaps, user research
  • marketing — Content, campaigns, brand voice
  • legal — Contract review, compliance, risk
  • finance — Journal entries, reconciliation, audits
  • data — SQL, visualization, dashboards
  • enterprise-search — Cross-tool search
  • bio-research — Preclinical research tools
  • cowork-plugin-management — Meta: create/customize plugins

Each connects to real tools via MCP — Slack, Notion, Jira, HubSpot, Snowflake, and dozens more.

financial-services-plugins

Enterprise-grade financial analysis: investment banking, equity research, private equity, wealth management. 41 skills, 38 commands, 11 data provider integrations (S&P Global, FactSet, Moody’s, PitchBook, etc.).

This repo demonstrates how far the plugin system can go — from generating DCF models to preparing IC memos to running portfolio analysis.

Layer 5: CI/CD Automation

claude-code-action

The bridge between Claude and your CI/CD pipeline. Two modes:

Interactive: Add @claude to any PR comment or issue, and Claude responds — reading code, suggesting fixes, or implementing changes directly.

Automated: Trigger via workflow_dispatch for scheduled tasks — nightly code reviews, PR labeling, security scanning.

- uses: anthropics/claude-code-action@v1
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    # Claude responds to @claude mentions in PRs

It supports Anthropic API, AWS Bedrock, Google Vertex AI, and Microsoft Foundry for authentication.

claude-code-base-action

The lower-level building block. Where claude-code-action is opinionated (PR reviews, issue responses), base-action gives you raw Claude Code execution in CI:

- uses: anthropics/claude-code-base-action@v1
  with:
    prompt: "Run all tests and fix any failures"
    allowed_tools: "Bash,Read,Write,Edit"
    max_turns: 20

Use this when you need custom automation that doesn’t fit the standard patterns — running migrations, generating documentation, updating dependencies.

Layer 6: Security & Monitoring

claude-code-security-review

An AI-powered security scanner that runs on every PR. Unlike pattern-matching tools (SAST), this uses Claude to understand semantic vulnerabilities:

  • Injection attacks (SQL, command, LDAP, XXE)
  • Auth bypass and privilege escalation
  • Hardcoded secrets and data exposure
  • Business logic flaws (race conditions, TOCTOU)
  • Supply chain risks

It filters false positives automatically and comments findings directly on the PR. Default model: Opus 4.1.

claude-code-monitoring-guide

A complete observability setup: Prometheus + OpenTelemetry configuration, cost tracking by model, usage analytics, productivity metrics (PR count, commit frequency), and team adoption dashboards.

This is the “prove the ROI” toolkit — essential for enterprises evaluating Claude Code adoption.

Layer 7: Learning & Onboarding

These repos form a natural learning path:

courses

5 structured courses in recommended order:

  1. API Fundamentals — SDK basics, parameters, streaming
  2. Prompt Engineering — Interactive techniques
  3. Real World Prompting — Production patterns
  4. Prompt Evaluations — Measuring quality
  5. Tool Use — Function calling workflows

claude-cookbooks

Copy-paste recipes for specific tasks: classification, RAG, summarization, text-to-SQL, vision, sub-agents, and more. Jupyter notebooks you can run immediately.

claude-quickstarts

5 complete application templates:

  • Customer Support Agent
  • Financial Data Analyst
  • Computer Use Demo (desktop automation)
  • Browser Tools API Demo
  • Autonomous Coding Agent (2-agent pattern)

devcontainer-features

One-line Claude Code setup for Dev Containers and GitHub Codespaces:

{
  "features": {
    "ghcr.io/anthropics/devcontainer-features/claude-code:1": {}
  }
}

Zero-friction onboarding in containerized environments.

How Everything Connects

Here’s the key insight: these aren’t 22 independent projects. They’re 22 components of one platform.

The data flow looks like this:

Developer learns (courses → cookbooks → quickstarts)
         │
         ▼
Builds with API SDK (anthropic-sdk-python/ts)
         │
         ▼
Upgrades to Agent SDK (agent-sdk-python/ts)
    for autonomous agents
         │
         ├──→ Uses Claude Code as runtime engine
         │
         ├──→ Extends with Plugins & Skills
         │        (plugins-official, skills,
         │         knowledge-work, financial)
         │
         ├──→ Connects to external tools via MCP
         │        (github-mcp-server, etc.)
         │
         └──→ Deploys to CI/CD
                  (claude-code-action, base-action)
                       │
                       ├──→ Security scanning
                       │    (security-review)
                       │
                       └──→ Monitoring & ROI
                            (monitoring-guide)

The Constitution sits underneath everything, defining the behavioral boundaries.

The CLI tools (claude-code, anthropic-cli) provide direct human interfaces.

The Demos show how all the pieces combine in real applications.

What This Means for Developers

If you’re just starting

Start with courses → try Claude Code → experiment with cookbooks. You don’t need to understand the full ecosystem on day one.

If you’re building a product

Use the API SDK for simple integrations, upgrade to the Agent SDK when you need autonomous capabilities. Add MCP servers for external tool access. Study the demos for architecture patterns.

If you’re running a team

Deploy claude-code-action for automated PR reviews. Add security-review for vulnerability scanning. Use the monitoring guide to track ROI. Install knowledge-work-plugins to give every team member a domain-expert Claude.

If you’re extending the platform

The plugin format is just markdown and JSON — no code required. The skills spec is even simpler. Fork, customize, contribute back.

The Bigger Picture

What Anthropic is building isn’t just an AI model. It’s a developer platform with the same layered architecture you’d expect from AWS, Vercel, or GitHub:

  • Compute layer (Claude models)
  • SDK layer (API + Agent SDKs)
  • Runtime layer (Claude Code)
  • Protocol layer (MCP)
  • Extension layer (Plugins + Skills)
  • Automation layer (GitHub Actions)
  • Observability layer (Monitoring + Security)
  • Education layer (Courses + Cookbooks + Quickstarts)

Every layer builds on the one below. Every component has a clear responsibility. And the entire thing is open source.

The repos I’ve mapped here aren’t the end — they’re the foundation. As Anthropic continues to ship, each layer will grow. New MCP servers. New plugins. New quickstarts. New courses.

The developers who understand this architecture — who see the 22 repos as one system — will be the ones who build the most powerful things with it.

All 22 repositories are available at github.com/anthropics. This article reflects the ecosystem as of February 2026.