skills.rest
fsolla
fsollaCOMMUNITY
Explore all skills by this author →
Website𝕏@franciscosollaGitHub

api-and-interface-design

Standardize REST, GraphQL API contracts with error handling and backward compatibility rules.

Updated Jul 31, 2026
Search Tags:#typescript#architecture#api#rest#graphql#interface
One-click install
npx skills add https://github.com/fsolla/teqo --skill api-and-interface-design-fsolla
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: api-and-interface-design
Source: https://github.com/fsolla/teqo/tree/main/.agents/skills/api-and-interface-design
Command: npx skills add https://github.com/fsolla/teqo --skill api-and-interface-design-fsolla

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses the challenge of creating stable software interfaces that are resistant to breaking changes and misuse, ensuring long-term maintainability and developer productivity.

Core Features & Use Cases

  • Contract-First Design: Provides patterns for defining API schemas and type contracts before implementation.
  • Boundary Validation: Offers strategies for validating untrusted input at system edges to maintain internal code integrity.
  • Use Case: When designing a new microservice or module, use this skill to establish consistent error semantics, pagination standards, and backward-compatible interface evolution.

Quick Start

Use the api-and-interface-design skill to review my proposed API schema for consistency and adherence to contract-first principles.

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 a REST API schema that prevents breaking changes?▼

Apply contract-first design patterns to define schemas and type contracts before implementation, ensuring backward compatibility and preventing breaking changes in your REST API.

What is contract-first API design and when should I use it?▼

Contract-first API design defines schemas, error semantics, and type contracts before writing implementation code. Use it when designing new microservices or module boundaries to ensure stable interfaces.

How do I validate untrusted input at system boundaries in TypeScript?▼

Validate untrusted input at system edges using boundary validation strategies to maintain internal code integrity, ensuring invalid data is rejected before entering your TypeScript module boundaries.

Does this interface design approach work for both REST and GraphQL?▼

Yes, these interface design patterns apply to REST, GraphQL, and internal module boundary definitions across frontend and backend systems, standardizing error handling and pagination consistently.

How do I establish consistent error handling and pagination standards for a new microservice?▼

Establish consistent error handling and pagination by applying strict interface design patterns to your API contracts, standardizing semantics across frontend and backend systems during microservice creation.

Related Skills

Explore More Software Engineering Skills→
LazyIsEfficientLazyIsEfficient
15

api-and-interface-design

Define typed API contracts with consistent error semantics and boundary validation.

Official
Advanced
LeonardoTan19LeonardoTan19
2

api-client-gen

Generate a typed TypeScript API client from Strapi content-type schemas and route contracts.

Community
Advanced
Sir-chawakornSir-chawakorn
9

type-safety-strict

Enforce strict static type checking and runtime boundary validation in TypeScript and Python codebases.

Community
Advanced
rsmdtrsmdt
381

api-design-patterns

Apply standardized REST and GraphQL design patterns to API contracts and versioning.

Community
Advanced