Best AI Skills for API Development [2026]

We installed 13 API development skills from the SkillSafe registry, read every file in every archive, and scored them on five dimensions: relevance to real API concerns, depth of content, actionability, structural organization, and adoption. Most API skills in the registry are thin single-file overviews that restate what you already know about REST conventions. A few go further. Five stood out: they contain enough concrete detail — specific framework patterns, working scripts, RFC references, production checklists — to meaningfully change how an AI builds and reviews APIs.

These are the five we would recommend. Each review describes the archive structure, quotes specific content, and names what the skill gets right and where it falls short.

How We Scored

Each skill was scored out of 50 across five dimensions:

Dimension	Max	What we looked at
Relevance	10	Does it address real API concerns: REST design, versioning, error handling, OpenAPI, GraphQL, authentication?
Depth	10	Line count, number of files, specific patterns and schemas vs. vague principles
Actionability	10	Can a developer follow the guidance to build better APIs right now?
Structure	10	Directory organization, navigability, coverage of the API lifecycle
Adoption	10	Install count, stars, verifications, update frequency

Single-file skills scored lower on structure even when their content was strong. Skills from mega-collections (100+ skills in one repo) scored lower on depth when their API content was generic filler.

Quick Comparison

Skill	Score	Key Feature	Frameworks / Protocols	Installs
@ancoleman/implementing-api-patterns	45/50	25 files across 7 frameworks	FastAPI, Hono, Axum, Gin, tRPC, Strawberry, Tonic	8,218
@yonatangross/api-design	44/50	RFC 9457 errors + agent-facing extensions	REST, OpenAPI, RFC 9457, Express	5,381
@ancoleman/designing-apis	43/50	Protocol decision matrix + 8 reference docs	REST, GraphQL, gRPC, OAuth, JWT	9,123
@apollographql/graphql-schema	41/50	Schema design from Apollo’s own team	GraphQL, Apollo Server, Federation	7,016
@wshobson/api-design-principles	40/50	REST + GraphQL with working templates	REST, GraphQL, OpenAPI 3.0	3,080

1. @ancoleman/implementing-api-patterns — 45/50

Source: github.com/ancoleman · 8,218 installs

This is the largest and most implementation-focused API skill in the registry. It ships 25 files across 9 reference documents, 7 framework-specific examples, and 3 executable scripts. Where most API skills stay at the design level, this one gives you working code in FastAPI, Hono, Axum, Gin, Strawberry (GraphQL), Tonic (gRPC), and tRPC.

Archive structure:

SKILL.md                                  <- hub with decision framework
references/
  rest-design-principles.md    (543 lines)
  graphql-schema-design.md     (643 lines)
  grpc-protobuf-guide.md       (643 lines)
  trpc-setup-guide.md          (742 lines)
  pagination-patterns.md       (594 lines)
  rate-limiting-strategies.md  (391 lines)
  caching-patterns.md          (530 lines)
  versioning-strategies.md     (555 lines)
  openapi-documentation.md     (527 lines)
examples/
  python-fastapi/main.py       (327 lines)
  typescript-hono/index.ts     (361 lines)
  typescript-trpc/              ...
  rust-axum/                    ...
  go-gin/                       ...
  graphql-strawberry/           ...
  grpc-tonic/                   ...
scripts/
  generate_openapi.py
  validate_api_spec.py
  benchmark_endpoints.py

The hub SKILL.md opens with a decision tree that is the most useful part of the entire archive. It maps “Who consumes your API?” to a framework recommendation with throughput numbers: Axum at 140k req/s for maximum performance, Hono at 50k req/s for edge deployment, FastAPI at 40k req/s for developer experience. That kind of comparative framing is what agents need — a heuristic, not a menu.

The tRPC setup guide at 742 lines is the deepest single reference file. It covers router patterns, middleware chains, Zod validation, WebSocket subscriptions, and React Query integration. The gRPC guide is equally thorough: Proto3 syntax, service definitions, server and bidirectional streaming, and client-side retry configuration.

The three scripts are a standout feature. generate_openapi.py extracts OpenAPI specs from running code, validate_api_spec.py checks OpenAPI 3.1 compliance, and benchmark_endpoints.py load-tests endpoints. These are not instructional — they are tools the agent can run.

Where it loses points: The examples are starter templates, not production-grade applications. The FastAPI main.py shows the patterns but doesn’t include database integration, error handling middleware, or authentication. A developer following the example would need to combine it with guidance from the reference files, which is doable but adds friction.

Score breakdown: Relevance 9/10 · Depth 10/10 · Actionability 9/10 · Structure 9/10 · Adoption 8/10

skillsafe install @ancoleman/implementing-api-patterns

2. @yonatangross/api-design — 44/50

Source: github.com/yonatangross · 5,381 installs

This skill takes a rules-based approach to API design, shipping 47 files organized into rules, references, checklists, examples, and scripts. Its distinguishing feature is its treatment of RFC 9457 Problem Details — not just as an error format, but as a system with agent-facing extensions, error catalogs, and validation patterns.

Archive structure:

SKILL.md                              <- overview + capability index
rules/                                <- 18 individual rule files
  framework-rest-conventions.md
  framework-resource-modeling.md
  framework-openapi.md
  versioning-url-path.md
  versioning-header.md
  versioning-deprecation.md
  errors-problem-details.md
  errors-agent-facing.md              <- unique
  errors-validation.md
  errors-error-catalog.md
  graphql-strawberry.md
  graphql-schema.md
  grpc-service.md
  grpc-streaming.md
  streaming-sse.md
  streaming-websocket.md
  messaging-integrations.md
  payload-cms.md
checklists/
  api-design-checklist.md    (293 lines)
  error-handling-checklist.md (184 lines)
  versioning-checklist.md    (202 lines)
examples/
  fastapi-versioning.md      (412 lines)
  fastapi-problem-details.md (452 lines)
scripts/
  fastapi-versioned-router.py (407 lines)
  problem-detail-exceptions.py (396 lines)
test-cases.json              (193 lines, 9 test cases)

The errors-agent-facing.md rule is the most distinctive content in any API skill we reviewed. It extends RFC 9457 with operational fields for AI agent consumers: retryable (explicit boolean), error_category (enum: rate_limit, validation, timeout, quota, etc.), retry_after (seconds), and what_you_should_do (agent-optimized guidance under 50 words). The file quantifies the cost difference: a standard HTML error page costs approximately 14,000 tokens while a structured RFC 9457 response costs approximately 250 — a 98% reduction. In 2026, where AI agents are primary API consumers, this is forward-looking guidance that no other skill in the registry provides.

The three checklists are designed for pre-review use. The API design checklist covers 293 lines of items organized by lifecycle stage: resource modeling, endpoint design, error responses, pagination, rate limiting, authentication, and documentation. These are not abstract principles — they are specific verification items like “all collection endpoints return cursor-based pagination” and “error responses include application/problem+json content type.”

The fastapi-versioned-router.py script (407 lines) is a working implementation of URL-path versioning with automatic version detection, deprecation headers, and sunset scheduling. The problem-detail-exceptions.py script (396 lines) implements the full RFC 9457 exception hierarchy with Pydantic models.

Where it loses points: Some reference files are thin. The grpc-api.md reference is only 68 lines, and the graphql-api.md reference is 129 lines — both are overviews rather than implementation guides. The skill covers breadth (18 rules across 7 categories) at the cost of depth in some areas. Also, some references like WhatsApp WAHA and Telegram Bot API integrations feel tangential to core API design.

Score breakdown: Relevance 10/10 · Depth 9/10 · Actionability 9/10 · Structure 9/10 · Adoption 7/10

skillsafe install @yonatangross/api-design

3. @ancoleman/designing-apis — 43/50

Source: github.com/ancoleman · 9,123 installs

This is the design-phase counterpart to @ancoleman/implementing-api-patterns. Where that skill gives you code, this one gives you the decisions that come before code: which API style to choose, how to version, what error format to use, how to handle authentication. It ships 13 files with 8 reference documents and a validation script.

Archive structure:

SKILL.md                             <- decision matrices + quick reference
references/
  rest-design.md             (713 lines)
  versioning-strategies.md   (607 lines)
  error-handling.md          (507 lines)
  authentication.md          (412 lines)
  graphql-design.md          (325 lines)
  rate-limiting.md           (318 lines)
  pagination-patterns.md     (240 lines)
  protocol-selection.md      (229 lines)
examples/
  asyncapi/order-events.yaml (104 lines)
  graphql/schema.graphql     (100 lines)
scripts/
  validate-openapi.sh

The hub SKILL.md is the best-organized of any API skill we reviewed. It opens with a protocol decision matrix comparing REST, GraphQL, WebSocket, and message queues across five factors (public API suitability, complex data handling, caching, real-time support, simplicity) using a star rating. Below that, it covers versioning with a concrete deprecation timeline: month 0 announce, months 1-3 migration, months 4-6 warnings, month 6 sunset with 410 Gone. The deprecation headers section shows the exact HTTP headers (Deprecation: true, Sunset:, Link: rel="successor-version") that a well-behaved API should return.

The rest-design.md reference at 713 lines is the longest file in the archive and covers HTTP method semantics, status codes (with an idempotent/safe table), resource naming conventions, nested resource depth limits, content negotiation, and HATEOAS patterns. The authentication.md reference at 412 lines walks through OAuth 2.0 Authorization Code and Client Credentials flows, scope-based authorization with granular permissions, and API key management with environment prefixes (sk_live_*, sk_test_*).

The skill explicitly delineates its scope from its sibling: “Do NOT use for implementation code (use api-patterns skill)” and “Do NOT use for API testing strategies.” That clarity helps agents avoid loading the wrong skill.

Where it loses points: The pagination-patterns.md reference at 240 lines is thinner than expected — cursor-based and offset-based are covered but keyset pagination gets minimal treatment. The validate-openapi.sh script is a thin wrapper (23 lines). The AsyncAPI example is useful but the skill could go deeper on event-driven patterns.

Score breakdown: Relevance 10/10 · Depth 8/10 · Actionability 8/10 · Structure 9/10 · Adoption 8/10

skillsafe install @ancoleman/designing-apis

4. @apollographql/graphql-schema — 41/50

Source: github.com/apollographql · 7,016 installs

This is a GraphQL-only skill from Apollo’s own team, and it reflects the authority you would expect. Six files, all focused on schema design: types, naming, pagination, errors, and security. No REST, no gRPC, no framework code — just GraphQL schema design done right.

Archive structure:

SKILL.md                    <- principles + ground rules
references/
  types.md       (445 lines)
  naming.md      (400 lines)
  pagination.md  (396 lines)
  errors.md      (388 lines)
  security.md    (484 lines)

The SKILL.md hub establishes ground rules that are specific enough to be enforceable: “ALWAYS use [Type!]! pattern for lists,” “NEVER expose database internals in schema,” “USE ID type for identifiers, not String or Int,” “USE custom scalars for domain-specific values (DateTime, Email, URL).” The nullability table — mapping String, String!, [String], [String!], [String]!, [String!]! to their meanings — is the kind of reference that prevents real bugs in generated GraphQL code.

The security.md reference at 484 lines is the deepest file. It covers query depth limiting, query complexity analysis, field-level authorization, rate limiting per operation, persisted queries, and introspection disabling in production. The pagination.md file implements the Relay Connection specification with edges, pageInfo, totalCount, and cursor encoding/decoding patterns.

The errors.md file (388 lines) takes a position on how to model errors in GraphQL — using result union types (type CreateUserResult = CreateUserSuccess | ValidationError | NotFoundError) rather than relying on the top-level errors array. This is an opinionated choice backed by Apollo’s experience, and it produces more type-safe client code than the alternative.

Where it loses points: The scope is intentionally narrow. If you need REST patterns, versioning strategies, or implementation code, you need a different skill. The skill also has zero stars and zero verifications despite 7,016 installs, which suggests bulk adoption (likely from the Apollo organization’s GitHub import) rather than individual endorsement. There are no working code examples or scripts — everything is schema-level guidance.

Score breakdown: Relevance 8/10 · Depth 9/10 · Actionability 7/10 · Structure 9/10 · Adoption 8/10

skillsafe install @apollographql/graphql-schema

5. @wshobson/api-design-principles — 40/50

Source: github.com/wshobson/agents · 3,080 installs · 53 stars · 8 verifications

This skill covers both REST and GraphQL in a single 528-line SKILL.md, backed by two reference files, a checklist, and a working FastAPI template. It is the best-balanced general-purpose API skill for teams that need coverage of both paradigms without committing to 25+ files.

Archive structure:

SKILL.md                                    <- 528 lines
references/
  rest-best-practices.md         (408 lines)
  graphql-schema-design.md       (583 lines)
assets/
  api-design-checklist.md        (155 lines)
  rest-api-template.py           (182 lines)

The SKILL.md covers four REST patterns (resource collection design, pagination with Pydantic models, error handling with status code mapping, HATEOAS) and three GraphQL patterns (Relay-style schema design, resolver design with cursor-based pagination, DataLoader for N+1 prevention). Each pattern includes complete Python code, not pseudocode. The pagination pattern shows a PaginatedResponse model with has_next and has_prev properties and a FastAPI endpoint that calculates offset from page number — a working implementation an agent can adapt.

The GraphQL section is stronger than expected for a general-purpose skill. The Relay Connection specification (OrderConnection, OrderEdge, PageInfo) is implemented correctly, and the DataLoader pattern shows both UserLoader and OrdersByUserLoader with proper batch loading and result-ordering logic. The resolver design pattern includes cursor encoding/decoding and the “fetch one extra to check hasNextPage” technique.

The rest-api-template.py at 182 lines is a FastAPI application template with CORS configuration, error handlers, health check endpoint, and pagination utilities. It is immediately usable as a project starting point.

This skill has the best community metrics of any API skill we reviewed: 53 stars, 8 verifications, and consistent updates (most recently March 2026). The stars-to-installs ratio suggests genuine individual adoption rather than organizational bulk imports.

Where it loses points: No coverage of gRPC, tRPC, or event-driven patterns. No versioning strategy guidance. No rate limiting or authentication patterns. The best practices section at the end of SKILL.md is a bullet list of generic advice (“Use HTTP Status Codes Correctly,” “Pagination: Always paginate large collections”) that doesn’t add much beyond what the patterns already demonstrate. The checklist at 155 lines is useful but thinner than the checklists in @yonatangross/api-design.

Score breakdown: Relevance 8/10 · Depth 7/10 · Actionability 9/10 · Structure 8/10 · Adoption 8/10

skillsafe install @wshobson/api-design-principles

Frequently Asked Questions

How do these API skills differ from general TypeScript or Python skills?

API skills focus on protocol-level concerns that language skills do not cover: HTTP method semantics, status code selection, pagination strategies, versioning policies, error response formats (RFC 9457), rate limiting algorithms, and OpenAPI specification authoring. A Python skill might teach you FastAPI syntax, but it will not tell you when to use cursor-based pagination over offset-based, or how to structure deprecation headers for a sunsetting API version. The five skills in this roundup address the design and architecture layer that sits between your language/framework and your consumers. They are complementary to language skills, not replacements.

Should I install all five or pick one?

It depends on your stack and your API’s maturity. For a greenfield project, start with @ancoleman/designing-apis (decisions) and @ancoleman/implementing-api-patterns (code) — they are designed as a pair from the same author and cover the full lifecycle from protocol selection to working endpoints in 7 frameworks. If your API is already built and you are focused on error handling and versioning governance, @yonatangross/api-design with its 18 rules and 3 checklists is the strongest choice. For GraphQL-only projects, @apollographql/graphql-schema is authoritative and focused. For a single general-purpose install that covers both REST and GraphQL fundamentals without 25 files of overhead, @wshobson/api-design-principles is the most balanced option.

What about the other skills we evaluated?

We evaluated 13 skills total. Several were decent but did not make the top five. @jeffallan/api-designer (5,236 installs) has strong reference files — its openapi.md is 824 lines — but its hub SKILL.md is only 90 lines and reads more like a role-play prompt than actionable guidance. @softaworks/openapi-to-typescript (8,883 installs) does one thing well (OpenAPI-to-TypeScript conversion with type guards) but is too narrow for a general API roundup. @patricio0312rev/api-versioning-deprecation-planner (5,267 installs) is a solid single-file versioning guide with migration templates and rollback plans, but its scope is a subset of what @yonatangross/api-design and @ancoleman/designing-apis already cover more thoroughly. Three skills from the @patricio0312rev mega-collection (api-docs-generator, api-endpoint-generator, api-versioning-deprecation-planner) are part of a 100+ skill repository — individually they are competent but generic.

Conclusion

If you install one skill from this list, install @ancoleman/implementing-api-patterns — 25 files, 7 framework examples, 3 executable scripts, and the most thorough implementation-level coverage of REST, GraphQL, gRPC, and tRPC in the registry. Pair it with @ancoleman/designing-apis for the design-phase decisions that come before code.

For teams that care about API governance — error standards, versioning policies, deprecation timelines — @yonatangross/api-design is the one to reach for. Its agent-facing error extensions (RFC 9457 + operational fields for AI consumers) are unique in the registry and increasingly relevant as AI agents become primary API clients.

For GraphQL projects, @apollographql/graphql-schema carries the authority of Apollo’s own team with focused, opinionated guidance on schema design, pagination, and security. And for a single balanced install that covers both REST and GraphQL with working Python code, @wshobson/api-design-principles earns its 53 stars and 8 verifications.

# Install all five
skillsafe install @ancoleman/implementing-api-patterns
skillsafe install @yonatangross/api-design
skillsafe install @ancoleman/designing-apis
skillsafe install @apollographql/graphql-schema
skillsafe install @wshobson/api-design-principles

Related roundups: Browse all Best Of roundups