design-an-interface

Generates multiple radically different interface designs for a module using parallel sub-agents.

2|Updated Apr 29, 2026
One-click install
npx skills add https://github.com/siarhei-belavus/agent-public --skill design-an-interface-siarhei-belavus
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: design-an-interface
Source: https://github.com/siarhei-belavus/agent-public/tree/main/skills/design/design-an-interface
Command: npx skills add https://github.com/siarhei-belavus/agent-public --skill design-an-interface-siarhei-belavus

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? First interface design ideas are rarely the best, and teams often commit to a single API shape without exploring alternatives. This Skill applies the "Design It Twice" principle from "A Philosophy of Software Design" to generate and compare multiple radically different interface designs before implementation. ## Core Features & Use Cases - Parallel Design Generation: Spawns 3+ sub-agents simultaneously, each constrained to produce a radically different interface approach (minimal methods, maximum flexibility, common-case optimization, paradigm-inspired). - Structured Comparison: Evaluates designs on interface simplicity, generality, implementation efficiency, module depth, and ease of correct use versus misuse. - Synthesis Guidance: Helps combine the strongest elements from multiple designs into a final interface. - Use Case: When designing a new caching module's API, use this Skill to explore a minimal two-method design, a flexible builder-style design, and a design inspired by an existing library, then compare their trade-offs before writing any code. ## Quick Start Ask the assistant to design an interface for your module using the design-an-interface skill, describing what the module does and who will call it.

Frequently Asked Questions about design-an-interface

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

FAQPage Schema
How do I design a good module interface before writing code?▼

Generate multiple radically different interface designs in parallel, then compare them on simplicity, generality, and depth. This Skill spawns sub-agents with distinct constraints so each explores a different design philosophy before you commit.

What is the Design It Twice principle in software design?▼

Design It Twice, from "A Philosophy of Software Design", states that your first design idea is unlikely to be the best. Producing several contrasting designs and comparing their trade-offs leads to simpler, deeper interfaces.

How do I compare different API design options?▼

Compare designs on interface simplicity, general-purpose versus specialized shape, implementation efficiency, module depth, and ease of correct use versus misuse. Discuss trade-offs in prose and highlight where designs diverge most.

When should I not use parallel interface design exploration?▼

Skip it when the interface is trivial, dictated by an existing standard, or when you need implementation rather than design. This Skill is purely about interface shape and does not produce working code.

Does this Skill implement the interface it designs?▼

No, it only explores and compares interface shapes. Implementation is explicitly out of scope; the output is design options with signatures, usage examples, and trade-off analysis.