api-and-interface-design

Design stable REST and GraphQL APIs with typed contracts and additive evolution.

Updated Dec 27, 2025
One-click install
npx skills add https://github.com/Lauughter/Python_training --skill api-and-interface-design-lauughter
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: api-and-interface-design
Source: https://github.com/Lauughter/Python_training/tree/main/.claude/skills/api-and-interface-design
Command: npx skills add https://github.com/Lauughter/Python_training --skill api-and-interface-design-lauughter

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Provide a framework to design stable APIs and public interfaces to prevent misuse and breaking changes.

Core Features & Use Cases

  • Contract-first design for REST and GraphQL endpoints, module boundaries, and component props
  • Consistent error semantics and typed input/output contracts
  • Safe evolution guidelines that prefer additive changes and clear deprecation paths

Quick Start

Describe a stable API contract for a new module and outline its public interface.

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 APIs and prevent breaking changes across teams?

To design stable APIs and prevent breaking changes, use a contract-first framework that enforces typed inputs, consistent error semantics, and additive, backward-compatible evolution for public interfaces.

What is contract-first design for REST and GraphQL endpoints?

Contract-first design for REST and GraphQL is defining typed inputs, outputs, and error semantics before implementation to enforce clear module boundaries and component props across teams.

How do I evolve APIs safely without breaking existing clients?

You can evolve APIs safely by following safe evolution guidelines that prefer additive changes and establish clear deprecation paths, ensuring backward compatibility for existing module boundaries.

When do I need typed inputs and outputs for module boundaries?

You need typed inputs and outputs for module boundaries when establishing clear component contracts across teams to prevent misuse and ensure consistent interface design.

Does this API design framework work for both REST and GraphQL?

Yes, this API design framework applies to both REST and GraphQL endpoints, enforcing consistent error handling and typed contracts for public interfaces and module boundaries.

What's the best way to handle error semantics in public interfaces?

The best way to handle error semantics in public interfaces is to enforce consistent error handling across all module boundaries and component contracts as part of your stable API design.