api-and-interface-design

Enforce stable REST and GraphQL API contracts with consistent validation and naming.

2|Updated Apr 9, 2026
One-click install
npx skills add https://github.com/skytiger6724/qwen-skills --skill api-and-interface-design-skytiger6724
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: api-and-interface-design
Source: https://github.com/skytiger6724/qwen-skills/tree/main/api-and-interface-design
Command: npx skills add https://github.com/skytiger6724/qwen-skills --skill api-and-interface-design-skytiger6724

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill keeps APIs and public interfaces predictable by enforcing careful contracts, validation, naming, and documentation so that teams avoid accidental regressions, Hyrum's Law traps, and versioning chaos when users depend on observable behavior.

Core Features & Use Cases

  • Contract First: Define the interface before implementation so the spec becomes the single source of truth for REST endpoints, GraphQL schemas, and module boundaries.
  • Consistent errors and validation: Use a single error schema, validate at system edges, and treat third-party responses as untrusted to maintain consumer confidence across services and UI components.
  • Design verification: Review pagination, filtering, PATCH semantics, naming conventions, and additive extension strategies to keep public surfaces predictable for new APIs, module contracts, and frontend props.

Quick Start

Ask the skill to review your new API design and flag contract, validation, and naming inconsistencies before implementation begins.

Frequently Asked Questions about api-and-interface-design

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I design stable REST APIs and GraphQL schemas with clear contracts?

To design stable REST APIs and GraphQL schemas, define the interface contract first to establish a single source of truth, ensuring predictable observable behavior for consumers and preventing accidental regressions.

What is the best way to handle API validation boundaries and error semantics?

The best way to handle API validation boundaries is to validate untrusted third-party responses at system edges and enforce a single error schema to maintain consistent error semantics across services.

How do I avoid Hyrum's Law traps and versioning chaos in interface design?

Avoid Hyrum's Law traps and versioning chaos by enforcing careful contracts, naming conventions, and additive extension strategies that keep public module boundaries and component props predictable.

Can I review pagination, filtering, and PATCH semantics before implementing an API?

Yes, you can review pagination, filtering, and PATCH semantics before implementation by verifying design expectations against established naming conventions and contract principles to flag inconsistencies early.

Does contract-first design work for both external REST endpoints and internal module boundaries?

Yes, contract-first design works for external REST endpoints, GraphQL schemas, and internal module boundaries by treating the interface spec as the single source of truth for all consumers.

What are the limitations of relying on observable behavior for API versioning?

Relying on observable behavior for API versioning risks accidental regressions when users depend on undocumented behavior, making strict contract enforcement and additive extension strategies necessary to prevent breaking changes.