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-patternsHow to use api-patterns
- 1.Identify your API consumers and their requirements
- 2.Use the content map to locate relevant design files (api-style.md for style selection, rest.md for REST design, etc.)
- 3.Work through the decision checklist: consumer type, API style, response format, versioning, auth, rate limiting, documentation
- 4.Read the relevant files for your chosen style and constraints
- 5.Define request/response examples and rejection cases for your endpoint
- 6.Optionally run the api_validator.py script on your project for a heuristic scan
Use cases
- 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
- 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
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.
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.
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.
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.
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
| File | Description | When to Read |
|---|---|---|
api-style.md | REST vs GraphQL vs tRPC decision tree | Choosing API type |
rest.md | Resource naming, HTTP methods, status codes | Designing REST API |
response.md | Envelope pattern, error format, pagination | Response structure |
graphql.md | Schema design, when to use, security | Considering GraphQL |
trpc.md | TypeScript monorepo, type safety | TS fullstack projects |
versioning.md | URI/Header/Query versioning | API evolution planning |
auth.md | JWT, OAuth, Passkey, API Keys | Auth pattern selection |
rate-limiting.md | Token bucket, sliding window | API protection |
documentation.md | OpenAPI/Swagger best practices | Documentation |
security-testing.md | OWASP API Top 10, auth/authz testing | Security audits |
🔗 Related Skills
| Need | Skill |
|---|---|
| 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
| Script | Purpose | Command |
|---|---|---|
scripts/api_validator.py | Local 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.
Related skills
More from sickn33/agentic-awesome-skills and the wider catalog.

api-security-best-practices
Implement secure API design patterns: authentication, authorization, input validation, rate limiting, and vulnerability protection.

app-store-optimization
Complete App Store Optimization toolkit for researching, optimizing, and tracking mobile app performance.

architect-review
Master software architect for reviewing system design, scalability, and modern architecture patterns.

architecture
Structured framework for making and documenting architectural decisions with requirements analysis and trade-off evaluation.

audio-transcriber
Transform audio recordings into professional Markdown documentation with intelligent summaries using speech-to-text.

autonomous-agents
Build reliable autonomous agents with constrained loops, goal decomposition, and reflection patterns.