skills.rest
mortenbroesby
mortenbroesbyCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

api-and-interface-design

Define explicit and enforceable interface contracts across packages.

1|Updated Apr 5, 2026
Search Tags:#documentation#interfaces#compatibility#types#contract-design#apis#module-boundaries
One-click install
npx skills add https://github.com/mortenbroesby/playground --skill api-and-interface-design-mortenbroesby
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: api-and-interface-design
Source: https://github.com/mortenbroesby/playground/tree/main/.skills/api-and-interface-design
Command: npx skills add https://github.com/mortenbroesby/playground --skill api-and-interface-design-mortenbroesby

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Design contracts deliberately. Use when changing shared types, mount contracts, module boundaries, route payloads, or public interfaces.

Core Features & Use Cases

  • Clarify ownership and responsibility for contracts.
  • Minimize breaking changes with explicit compatibility guidelines.
  • Provide a verifiable process for updates, reviews, and verification.

Quick Start

Define the contract owner, enumerate inputs and outputs, and publish a changelog before every modification.

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 prevent contract drift when changing shared types and module boundaries?▼

To prevent contract drift, make module boundaries and shared types explicit and enforceable across packages by defining ownership, applying compatibility-preserving changes, and updating documentation before modifications.

What is the best way to manage breaking changes across public APIs?▼

Managing breaking changes across public APIs requires clarifying contract ownership, following explicit compatibility guidelines to minimize disruptions, and maintaining a verifiable process for updates and reviews.

How do I document route payloads and mount contracts for host-remote interactions?▼

Document route payloads and mount contracts by defining the contract owner, enumerating all inputs and outputs explicitly, and publishing a changelog to verify host-remote interactions before every modification.

When do I need explicit interface design for shared package types?▼

You need explicit interface design when changing shared types, mount contracts, module boundaries, route payloads, or public APIs, and during reviews of host-remote interactions to ensure compatibility and enforceable contracts.

Does this approach to interface design require specific framework dependencies?▼

No, this approach to interface design requires no specific framework dependencies, focusing instead on explicit ownership, compatibility-preserving changes, and documentation updates to shape stable contracts across packages.

Related Skills

Explore More Software Engineering Skills→
ZTE-AICloudZTE-AICloud
52

design-interface

Generate formal interface contracts from architecture documents and entity definitions.

Official
Advanced
johannesPettersson80johannesPettersson80
18

scena-release-hygiene

Automate scena release-readiness tasks including versioning, changelogs, and publish checks.

Community
Advanced
vtgiang-dotcomvtgiang-dotcom
3

api-patterns

Define REST and GraphQL APIs with consistent contracts and validation.

Community
Advanced
heaptracetechnologyheaptracetechnology
13

contract-test

Automate API contract testing with schema validation and OpenAPI checks.

Community
Advanced