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

Ready to run

npx skills add https://github.com/mortenbroesby/playground --skill api-and-interface-design-mortenbroesby

💬 Prompt for ChatGPT / Claude Chat▼

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.