pre-dev-api-design

Define component interfaces and data contracts before protocol selection.

205|26|Updated Oct 30, 2025

Search Tags:#architecture #integration #interfaces #microservices #API design #contracts #pre-development

Ready to run

npx skills add https://github.com/LerianStudio/ring --skill pre-dev-api-design

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: pre-dev-api-design
Source: https://github.com/LerianStudio/ring/tree/main/skills/pre-dev-api-design
Command: npx skills add https://github.com/LerianStudio/ring --skill pre-dev-api-design

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Jumping to implementation without defining component contracts leads to integration failures, inconsistent data structures, and blocked teams. This skill ensures clear, technology-agnostic interface specifications.

Core Features & Use Cases

Contract Definition: Defines operations, inputs, outputs, errors, and events for each component interface.
Technology Agnostic: Enforces abstract contract design, avoiding protocol-specific details (e.g., HTTP verbs, JSON formats).
Versioning Strategy: Guides the definition of how contract changes are managed, including backward compatibility and deprecation.

Quick Start

The TRD is approved. Use the pre-dev-api-design skill to define the API contracts for our new components.

Frequently Asked Questions about pre-dev-api-design

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

FAQPage Schema

Why define API contracts before choosing a protocol or implementation?▼

API contracts specify operations, inputs, outputs, and error handling independent of technology. Defining contracts first prevents integration failures, ensures consistent data structures across components, and lets teams develop in parallel without waiting for protocol decisions.

What should be included in an API contract definition?▼

API contracts include operation names and descriptions, input/output schemas, error codes and messages, event payloads, validation rules, rate limits, idempotency requirements, authentication/authorization needs, and a versioning strategy for managing changes and backward compatibility.

How do API contracts support parallel development across teams?▼

When component interfaces and data contracts are defined upfront, teams can build against agreed specifications simultaneously without blocking on implementation details. This accelerates delivery for large features with multiple integrating components.

Can API contracts work for both internal and external APIs?▼

Yes. Technology-agnostic contract design applies uniformly to internal microservices and external third-party APIs, ensuring consistent interface specifications and integration patterns across your system architecture.

What's the difference between defining contracts and selecting REST, gRPC, or other protocols?▼

Contracts are abstract, protocol-agnostic specifications of what data flows and operations exist. Protocols are the technology choices for delivery. Contracts come first; protocols are chosen afterward based on operational needs, avoiding rework when requirements change.

When in the development lifecycle should API contracts be defined?▼

API contracts should be defined during pre-development planning, after functional requirements are approved but before implementation begins. This gates contract completeness and prevents teams from discovering integration gaps during coding.