PluginBench
Skill
Pass
Audit score 90

api-patterns

sickn33/agentic-awesome-skills

API design principles for choosing REST, GraphQL, or tRPC and defining response formats, versioning, and pagination.

What is api-patterns?

Guidance on API architecture decisions tied to consumer requirements and deployment constraints. Use this when selecting an API style, designing endpoints, planning versioning strategy, or defining response structures and authentication patterns.

  • Decision tree for selecting REST vs GraphQL vs tRPC based on context
  • REST resource naming, HTTP methods, and status code conventions
  • Response envelope patterns, error formatting, and pagination strategies
  • GraphQL schema design and security considerations
  • tRPC type-safe patterns for TypeScript monorepos
  • API versioning approaches (URI, header, query parameter)

How to install api-patterns

npx skills add https://github.com/sickn33/agentic-awesome-skills --skill api-patterns
Claude Code
Cursor
Windsurf
Cline

How to use api-patterns

  1. 1.Identify your API consumers and their requirements
  2. 2.Use the content map to locate relevant design files (api-style.md for style selection, rest.md for REST design, etc.)
  3. 3.Work through the decision checklist: consumer type, API style, response format, versioning, auth, rate limiting, documentation
  4. 4.Read the relevant files for your chosen style and constraints
  5. 5.Define request/response examples and rejection cases for your endpoint
  6. 6.Optionally run the api_validator.py script on your project for a heuristic scan

Use cases

Good for
  • Choosing between REST and GraphQL for a new public API with multiple client types
  • Designing pagination for a large dataset that changes during client iteration
  • Planning API versioning strategy when adding breaking changes to an existing endpoint
  • Selecting authentication method for a mobile app, web client, and third-party integrations
  • Defining consistent error response format across microservices
Who it's for
  • Backend architects designing new APIs
  • Full-stack developers building TypeScript applications
  • API maintainers planning versioning and compatibility strategies
  • Teams evaluating REST vs GraphQL vs tRPC for their use case

api-patterns FAQ

When should I use REST vs GraphQL vs tRPC?

REST suits public APIs with diverse clients and simple queries. GraphQL fits complex, nested data requirements and multiple client types. tRPC is best for TypeScript monorepos where frontend and backend share types at build time.

How do I handle pagination for datasets that change during iteration?

Use cursor-based pagination with a stable sort order (e.g., created_at, id) rather than offset-based. Define cursor format, authorization filters, and behavior for removed or invalid records.

What versioning strategy should I use?

Choose based on your constraints: URI versioning (/v1/, /v2/) is explicit but verbose; header versioning is cleaner but less discoverable; query parameter versioning is flexible. Document your choice and compatibility obligations.

What authentication pattern should I pick?

JWT for stateless APIs and microservices; OAuth for delegated third-party access; API Keys for simple service-to-service; Passkeys for modern user authentication. Match your security and deployment model.

What does the api_validator.py script do?

It performs a local heuristic scan of your project using regex and shallow JSON/YAML checks to triage potential API design issues. It is not a full OpenAPI validator or security audit.

Full instructions (SKILL.md)

Source of truth, from sickn33/agentic-awesome-skills.


name: api-patterns description: "API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning, pagination." risk: none source: community date_added: "2026-02-27"

API Patterns

API design decisions tied to the consumers and deployment constraints. Learn to THINK, not copy fixed patterns.

🎯 Selective Reading Rule

Read ONLY files relevant to the request! Check the content map, find what you need.


📑 Content Map

FileDescriptionWhen to Read
api-style.mdREST vs GraphQL vs tRPC decision treeChoosing API type
rest.mdResource naming, HTTP methods, status codesDesigning REST API
response.mdEnvelope pattern, error format, paginationResponse structure
graphql.mdSchema design, when to use, securityConsidering GraphQL
trpc.mdTypeScript monorepo, type safetyTS fullstack projects
versioning.mdURI/Header/Query versioningAPI evolution planning
auth.mdJWT, OAuth, Passkey, API KeysAuth pattern selection
rate-limiting.mdToken bucket, sliding windowAPI protection
documentation.mdOpenAPI/Swagger best practicesDocumentation
security-testing.mdOWASP API Top 10, auth/authz testingSecurity audits

🔗 Related Skills

NeedSkill
API implementation@[skills/backend-architect]
Data structure@[skills/database-design]
Security details@[skills/api-security-best-practices]

✅ Decision Checklist

Before designing an API:

  • Asked user about API consumers?
  • Chosen API style for THIS context? (REST/GraphQL/tRPC)
  • Defined consistent response format?
  • Planned versioning strategy?
  • Considered authentication needs?
  • Planned rate limiting?
  • Documentation approach defined?

❌ Anti-Patterns

DON'T:

  • Default to REST for everything
  • Use verbs in REST endpoints (/getUsers)
  • Return inconsistent response formats
  • Expose internal errors to clients
  • Skip rate limiting

DO:

  • Choose API style based on context
  • Ask about client requirements
  • Document thoroughly
  • Use appropriate status codes

Script

ScriptPurposeCommand
scripts/api_validator.pyLocal heuristic source scan (not schema validation)python3 skills/api-patterns/scripts/api_validator.py <project_path>

When to Use

Use when defining a new endpoint contract, selecting REST/GraphQL/tRPC for known consumers, or changing pagination, errors, authentication or compatibility behavior. For a bug inside an existing contract, preserve that contract unless the task authorizes a change.

Inputs and procedure

Record consumers and deployed versions, expected payload size, access rules, compatibility obligations and one concrete operation. Read the relevant files in the map, compare the realistic choices, then specify request/response examples and rejection cases. Types shared at build time do not ensure that independently deployed clients remain compatible.

Worked example

Input: a public order list changes while clients page through it. Choose a bounded page size and cursor over a stable (created_at, id) order. Define the next-cursor format, authorization filter and behavior for a removed record or invalid cursor. Test two equal timestamps and an insertion between pages. Expected: no duplicate IDs within the promised snapshot semantics; document whether newly inserted rows can appear.

Limitations

  • The Python helper scans at most 15 matching files using regular expressions and shallow JSON/YAML checks. Its output is a triage hint, not OpenAPI validation, an authorization audit or deployment approval.
  • GraphQL query shape, tRPC inference and HTTP method names do not enforce resource authorization or backwards compatibility.
  • Rate limiting cannot alone prevent all resource exhaustion; size, concurrency, time and provider-cost bounds depend on the operation.
  • Perform security checks only against authorized local/test targets with isolated accounts and a defined scope.