pre-dev-api-design

Define component contracts with operations, inputs, outputs, and errors.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/withmartian-sandbox-darkside/ghrc-y-3126672651424eddb640ecc81321a665 --skill pre-dev-api-design-withmartian-sandbox-darkside
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: pre-dev-api-design
Source: https://github.com/withmartian-sandbox-darkside/ghrc-y-3126672651424eddb640ecc81321a665/tree/main/pm-team/skills/pre-dev-api-design
Command: npx skills add https://github.com/withmartian-sandbox-darkside/ghrc-y-3126672651424eddb640ecc81321a665 --skill pre-dev-api-design-withmartian-sandbox-darkside

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Abstracts away protocol and integration guesswork by defining stable component contracts before implementation, reducing rework and delays.

Core Features & Use Cases

  • Define operations, inputs, outputs, and errors for every component-to-component interaction.
  • Create technology-agnostic contracts that guide downstream design, testing, and integration across large programs.
  • Use Case: In a multi-service system, design contracts for service boundaries before selecting communication protocols to prevent mismatch.

Quick Start

Provide a high-level contract for two collaborating components: define operations and data shapes for their interfaces.

Frequently Asked Questions about pre-dev-api-design

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

FAQPage Schema
Why define component contracts before choosing a communication protocol?

Defining component contracts before choosing a communication protocol abstracts away integration guesswork. This approach creates technology-agnostic rules that prevent mismatched service boundaries and reduce downstream rework in multi-component systems.

How do I design API contracts for multi-service boundaries?

You design API contracts for multi-service boundaries by specifying operations, inputs, outputs, and errors for every component interaction. This provides a high-level contract guiding downstream design, testing, and integration across large programs.

What is protocol-agnostic API design?

Protocol-agnostic API design is the process of defining stable data interfaces and component operations without relying on specific communication protocols. It ensures contract completeness and data specification before implementation begins.

When do I need technology-agnostic data contracts?

You need technology-agnostic data contracts during API design, integration planning, and large-track features where component interfaces are unclear. They prevent integration gaps by defining stable data shapes before selecting technologies.

Does protocol-agnostic contract definition work for large track features?

Yes, protocol-agnostic contract definition works for large track features. It creates stable component contracts that guide testing and integration across large programs, reducing delays caused by unclear interfaces.