design-an-interface

Propose and compare at least three API designs for a module.

Updated Mar 18, 2026
One-click install
npx skills add https://github.com/Canepro/codex-skills --skill design-an-interface-canepro
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: design-an-interface
Source: https://github.com/Canepro/codex-skills/tree/main/skills/design-an-interface
Command: npx skills add https://github.com/Canepro/codex-skills --skill design-an-interface-canepro

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Designing APIs and module boundaries locks teams into a single shape too early, making future refactors costly and error-prone.

Core Features & Use Cases

  • Generate at least 3 radically different interface designs for a module and compare trade-offs.
  • Provide usage scenarios showing how each design handles common calls, errors, and evolution.
  • Support evaluation criteria such as simplicity, flexibility, and maintainability to inform decision making.

Quick Start

Provide three divergent interface designs for a module and compare their trade-offs.

Frequently Asked Questions about design-an-interface

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

FAQPage Schema
How do I compare different API designs for a new module?

To compare different API designs, you need to generate at least three distinct interface options for your module and evaluate their trade-offs. This process includes providing usage scenarios for common calls, errors, and evolution to inform your decision.

Why should I evaluate multiple interface designs before choosing an API direction?

Evaluating multiple interface designs prevents teams from locking into a single API shape too early. By comparing radically different options, you avoid costly and error-prone refactors later, ensuring the chosen module boundaries support future evolution effectively.

What is the best way to evaluate trade-offs between different API options?

The best way to evaluate API trade-offs is to apply specific criteria such as simplicity, flexibility, and maintainability. By generating usage scenarios for each design showing how they handle common calls and errors, you can clearly justify which option is best.

Can I use this approach to reshape existing module boundaries?

Yes, you can use this approach to reshape existing module boundaries. By proposing and comparing radically different API designs for the module, you can evaluate the public API options and select a new design direction that better fits your current architecture.

How do I generate divergent API designs for a single module?

To generate divergent API designs, you create at least three radically different interface proposals for the same module. You then document the specific trade-offs and justifications for each design, ensuring you have distinct options to compare before finalizing the boundaries.