evanflow-design-interface

Generate parallel interface designs and synthesize a final API shape.

417|18|Updated Apr 27, 2026

Search Tags:#design #synthesis #trade-offs #sub-agents #interface #api-design #parallel-design

Ready to run

npx skills add https://github.com/evanklem/evanflow --skill evanflow-design-interface

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: evanflow-design-interface
Source: https://github.com/evanklem/evanflow/tree/main/skills/evanflow-design-interface
Command: npx skills add https://github.com/evanklem/evanflow --skill evanflow-design-interface

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Design interface options for a module by running parallel sub-agents to generate radically different designs and a synthesis path to a final API shape.

Core Features & Use Cases

Parallel design exploration: Spawn 3+ agents, each with distinct constraints, to produce diverse interface options.
Structured comparison: Evaluate designs on depth, simplicity, and implementation feasibility, then synthesize the best compromise.
Design governance: Includes embedded grill questions to surface risks and trade-offs before committing to a design.
Use cases include designing new APIs, refactors, or module boundary decisions when multiple perspectives are valuable.

Quick Start

Generate three or more radically different interface designs in parallel, compare them on depth and simplicity, and synthesize a final API shape.

Frequently Asked Questions about evanflow-design-interface

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

FAQPage Schema

How do I generate and compare multiple API designs before writing code?▼

Parallel sub-agents generate radically different interface designs for a module, which are then evaluated on depth and simplicity to synthesize a final API shape. This approach surfaces trade-offs and risks before committing to a single design.

What is the best way to evaluate module boundary decisions for a refactor?▼

Generating multiple radically different interface designs in parallel provides diverse perspectives for module boundary decisions. Embedded grill questions surface risks and trade-offs, enabling a structured comparison on depth and simplicity before finalizing the refactor design.

How does parallel design exploration work for generating interface options?▼

Parallel design exploration spawns three or more sub-agents, each with distinct constraints, to produce diverse interface options. These designs are then evaluated on depth, simplicity, and implementation feasibility to synthesize the best compromise for the final API shape.

Can I use this approach to design new APIs without committing code?▼

Yes, this approach designs new APIs by providing multiple interface designs and a synthesis workflow to evaluate trade-offs. It ensures you finalize the API shape and review implementation feasibility before any actual coding begins.

When do I need to run parallel sub-agents for interface design?▼

Running parallel sub-agents for interface design is necessary when multiple perspectives are valuable, such as during new API creation, refactors, or module boundary decisions. It surfaces trade-offs and risks via embedded grill questions before committing to a design.

What are the limitations of using sub-agents to synthesize a final API shape?▼

A limitation of using sub-agents to synthesize a final API shape is that it does not commit code, focusing solely on design evaluation. The process relies on satisfying requirements for depth, simplicity, and implementation feasibility without generating the actual module implementation.