design-an-interface

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

Updated Jul 30, 2026
One-click install
npx skills add https://github.com/j172/bid --skill design-an-interface-j172
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: design-an-interface
Source: https://github.com/j172/bid/tree/main/agent/skills/design-an-interface
Command: npx skills add https://github.com/j172/bid --skill design-an-interface-j172

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? First design ideas are rarely the best, yet teams often commit to the initial interface they sketch. This Skill applies the "Design It Twice" principle from "A Philosophy of Software Design" to force exploration of multiple radically different interface shapes before committing to one. ## 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 generate a minimal 2-method design, a flexible builder-style design, and a get-or-compute design, then compare their trade-offs before writing any implementation. ## Quick Start Ask the agent to design an interface for your module, describing what it does, who calls it, and any constraints, then review the alternative designs it presents.

Frequently Asked Questions about design-an-interface

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

FAQPage Schema
How do I explore alternative API designs before implementing a module?

Describe the module's purpose, callers, key operations, and constraints, then have parallel sub-agents each design a radically different interface. Compare the results on simplicity, generality, and depth before choosing or synthesizing a final shape.

What is the Design It Twice approach to interface design?

Design It Twice, from "A Philosophy of Software Design", says your first idea is unlikely to be the best, so you should produce multiple radically different designs and compare them. The contrast between alternatives reveals trade-offs a single design would hide.

How do I compare two interface designs for the same module?

Compare designs on interface simplicity, general-purpose versus specialized shape, implementation efficiency, and module depth. Also weigh ease of correct use against ease of misuse, and discuss trade-offs in prose rather than scoring tables.

When should I not use parallel sub-agents for interface design?

Avoid it when the interface is trivial, already constrained by an existing pattern, or when you need implementation rather than interface shape. The approach adds value only when genuinely different design directions exist and the decision has lasting consequences.

What makes a module interface deep versus shallow?

A deep module has a small interface hiding significant internal complexity, which is desirable. A shallow module has a large interface over a thin implementation, which adds learning cost without hiding much complexity and should be avoided.