api-shape-explorer

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

4.6k|462|Updated Jun 21, 2025
One-click install
npx skills add https://github.com/zebbern/claude-code-guide --skill api-shape-explorer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: api-shape-explorer
Source: https://github.com/zebbern/claude-code-guide/tree/main/skills/api-shape-explorer
Command: npx skills add https://github.com/zebbern/claude-code-guide --skill api-shape-explorer

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

First interface design ideas are rarely the best, yet teams often commit to them without exploring alternatives. This Skill applies the "Design It Twice" principle from "A Philosophy of Software Design" to force exploration of radically different API 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 (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, use this Skill to generate four contrasting interfaces, compare their trade-offs in prose, and select or synthesize the best shape before writing any implementation.

Quick Start

Ask the agent to design the interface for your module twice using the api-shape-explorer approach, describing what the module does and who will call it.

Frequently Asked Questions about api-shape-explorer

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

FAQPage Schema
How do I design a better API interface for a module?

Generate multiple radically different interface designs in parallel rather than committing to your first idea. Assign each design a distinct constraint, such as minimizing method count or maximizing flexibility, then compare them on simplicity, depth, and ease of correct use.

What is the Design It Twice methodology?

Design It Twice comes from "A Philosophy of Software Design" and states that your first design idea is unlikely to be the best. The approach requires producing several contrasting designs and comparing their trade-offs before choosing one.

How do parallel sub-agents generate different API designs?

Each sub-agent receives the same module requirements but a different design constraint, such as minimizing methods, maximizing flexibility, or optimizing the common case. This forces genuinely divergent outputs rather than minor variations of one idea.

Does this Skill implement the interface it designs?

No, the Skill is purely about interface shape and explicitly avoids implementation. It produces interface signatures, usage examples, and trade-off comparisons so you can choose a design before writing code.

When should I not use parallel interface exploration?

Skip it for trivial modules with obvious shapes or when an existing pattern in the codebase must be followed for consistency. The comparison overhead is most valuable for modules with significant hidden complexity or unclear caller requirements.