principle-exhaust-the-design-space

Builds and compares competing prototypes before committing to novel design decisions.

3|2|Updated Aug 28, 2026
One-click install
npx skills add https://github.com/adjohn/pstack --skill principle-exhaust-the-design-space-adjohn
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: principle-exhaust-the-design-space
Source: https://github.com/adjohn/pstack/tree/main/skills/principle-exhaust-the-design-space
Command: npx skills add https://github.com/adjohn/pstack --skill principle-exhaust-the-design-space-adjohn

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? When facing a novel UI interaction or architectural decision with no precedent in the codebase, teams often commit to the first idea and pay the cost of building the wrong thing. This Skill enforces a disciplined exploration step before implementation. ## Core Features & Use Cases - Prototype Comparison: Directs the creation of 2-3 genuinely distinct competing prototypes or sketches, compared side by side before committing. - Applicability Rules: Clearly defines when the principle applies (novel UI interactions, architectural choices with multiple viable approaches, feel-driven product decisions) and when it does not (mechanical implementations, bug fixes, single-approach constraints). - Use Case: When designing a new drag-and-drop interaction with no prior art in the codebase, build three different interaction models, evaluate them side by side, and only then commit to one. ## Quick Start Ask the agent to apply the exhaust-the-design-space principle to your novel UI or architectural decision by building and comparing two or three competing prototypes before implementation.

Frequently Asked Questions about principle-exhaust-the-design-space

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

FAQPage Schema
How do I decide between multiple architectural approaches in a codebase?

Build 2-3 competing prototypes or sketches representing genuinely different approaches, then compare them side by side before committing. A second flavor of the same shape does not count as a distinct alternative.

When should I prototype multiple designs before implementing?

Prototype when facing novel UI interactions with no prior art in the codebase, architectural choices with several viable approaches, or product decisions where user experience depends on feel rather than logic.

When should I skip design exploration and just implement?

Skip exploration for mechanical implementations where the pattern is established, bug fixes or refactors with a clear target state, and changes where constraints dictate a single viable approach.

How many design alternatives should I explore before committing?

Build 2-3 competing prototypes or sketches. The alternatives must be genuinely different shapes, not minor variations of the first idea, and you should compare them side by side before committing.

What is the design it twice principle in software engineering?

Design it twice means exploring a second, genuinely different design instead of committing to your first idea. This Skill operationalizes that rule by requiring 2-3 competing prototypes compared side by side before implementation.