bee:pre-dev-api-design

Define protocol-agnostic API contracts and component interfaces with organizational standards.

2|1|Updated Mar 3, 2026
One-click install
npx skills add https://github.com/luanrodrigues/ia-frmwrk --skill bee-pre-dev-api-design
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: bee:pre-dev-api-design
Source: https://github.com/luanrodrigues/ia-frmwrk/tree/main/pm-team/skills/pre-dev-api-design
Command: npx skills add https://github.com/luanrodrigues/ia-frmwrk --skill bee-pre-dev-api-design

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill ensures that API contracts and component interfaces are clearly defined before any technology or protocol is selected, preventing integration failures and rework.

Core Features & Use Cases

  • Standardized API Design: Enforces organizational naming standards and best practices for API fields, data types, and error codes.
  • Protocol-Agnostic Contracts: Defines operations, inputs, outputs, and errors without specifying HTTP verbs, URLs, or serialization formats.
  • BFF Contract Definition: For specific project topologies, designs optimized data contracts for Backend-for-Frontend (BFF) layers.
  • Use Case: Before building a new microservice, use this Skill to document its public API, ensuring all other services know exactly what data and operations are available, and how to interact with them, without committing to a specific communication protocol yet.

Quick Start

Use the bee:pre-dev-api-design skill to define the API contract for the new user service, focusing on user creation and retrieval operations.

Frequently Asked Questions about bee:pre-dev-api-design

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

FAQPage Schema
Why define an API contract before choosing a communication protocol?

Defining an API contract before choosing a protocol prevents integration failures and rework. This protocol-agnostic approach specifies operations, inputs, outputs, and errors without committing to HTTP verbs or serialization formats, ensuring clarity before technology selection.

How do I design a Backend-for-Frontend (BFF) contract for a new microservice?

To design a BFF contract, define optimized data contracts tailored for Backend-for-Frontend layers. This process enforces organizational naming standards and documents public operations, data structures, and error handling before any microservice implementation begins.

What is the best way to enforce organizational API standards during contract design?

The best way to enforce organizational API standards is by applying protocol-agnostic contract design rules. This standardizes API fields, data types, and error codes across backend service contracts and BFF layers, ensuring consistency before implementation.

Can I define microservice interfaces without specifying HTTP verbs or URLs?

Yes, you can define microservice interfaces without specifying HTTP verbs or URLs. This protocol-agnostic contract design approach focuses on defining operations, data structures, and error handling independently of specific web protocols or serialization formats.

When do I need protocol-agnostic API contracts?

You need protocol-agnostic API contracts when building new microservices or Backend-for-Frontend layers. They ensure all services know exactly what data and operations are available without committing to a specific communication protocol early in the design phase.

What should a protocol-agnostic API contract include?

A protocol-agnostic API contract should include defined operations, inputs, outputs, data structures, and standardized error handling. It enforces organizational naming standards for API fields and data types without specifying underlying web protocols or formats.