human-avatar Design
Applies design thinking to problems of form, function, and fit — finding what people actually need, using constraints productively, shaping through iteration, and cutting to the essential. Diagnoses what kind of design work is needed and applies the right tool.
Which tool fits
| You need to... | Tool |
|---|---|
| Find what people actually need, beneath what they say they want | user-needs |
| Map hard limits versus soft preferences and understand the solution space they define | design-constraints |
| Structure a feedback loop between making and learning | iteration |
| Remove what's unnecessary and find the essential form | simplicity |
Routing Decision
Framing check: Confirm the design situation and the core question before routing. State what you've identified — the object being designed and the problem it needs to solve — in one sentence, then use AskUserQuestion:
Question: "I'm reading this as: [your one-sentence framing of the design situation and the core question]. Is that right?"
Header: "Framing"
Options:
- Yes — proceed — framing is correct
- Adjust — one element is off; user will correct it before you continue
- Reframe — different situation than read; incorporate the correction before proceeding
Don't know what the user actually needs, or the stated need feels like a proxy → user-needs
Have a list of constraints and need to understand what design space they leave → design-constraints
Have a direction but need to test and improve it through cycles → iteration
Something exists but feels bloated, cluttered, or over-engineered → simplicity
Unclear → user-needs first; most design failures begin with the wrong problem
Confirm Direction
After diagnosing which tool fits, use the AskUserQuestion tool to confirm direction. Construct the question dynamically to include your diagnosis:
- Question: "My read: [diagnosed tool] — [one sentence on why it fits]. How would you like to proceed?"
- Header: "Direction"
- Options:
- Yes, run that tool — Execute the diagnosed skill immediately using the context already provided
- Show all options — List every skill in this category with one-line descriptions
- Quick version — Run a lighter-weight alternative if one exists for this situation
- Re-diagnose — Revisit the situation description for a different read
Proceed based on their selection.
User Needs
Finds what people actually need, beneath what they say they want.
People state solutions, not needs. "I want a faster horse" is a solution; the underlying need is faster travel. This skill uses jobs-to-be-done framing and latent need mapping to separate the real need from the stated want. It surfaces the functional job (what they're trying to accomplish), the emotional job (how they want to feel), and the social job (how they want to be seen). The output is a need hierarchy that design can actually solve against.
Output: Stated want versus real need, jobs-to-be-done mapping (functional/emotional/social), latent needs not yet articulated by users, and the design target stated as a need rather than a solution.
Design Constraints
Uses constraints productively — mapping hard limits and soft preferences to understand what the solution space actually is.
Constraints are not the enemy of design; they are the definition of the problem. Every design exists within a set of limits — technical, physical, economic, regulatory, temporal. This skill distinguishes hard constraints (genuinely fixed) from soft preferences (negotiable), maps how they interact, and identifies where the tightest constraints focus the design space. The tightest genuine constraint often points directly to the solution.
Output: Constraint map (hard versus soft, by domain), interactions between constraints, the solution space they collectively define, and where productive design territory lies within that space.
Iteration
Structures the feedback loop between making and learning.
Good design cannot be planned in full from the start — it is discovered through cycles of making and testing. This skill structures the iteration loop: what to prototype, at what fidelity, with what question to answer, and how to read the signal from each test. It separates convergent tests (does this work?) from divergent tests (which direction?) and defines when enough learning has accumulated to narrow. Dieter Rams' ten principles and Don Norman's design of everyday things both emerge from this disciplined cycle of making and observing.
Output: Current design hypothesis, prototype specification (fidelity, format, what to make), test design (question, method, who to test with), decision criteria for converging or pivoting, and the next cycle.
Simplicity
Finds the form that does exactly what is needed — nothing more.
Rams' principle: good design is as little design as possible. The goal is not minimalism for its own sake but fitness — the form that serves the function completely, without residue. This skill applies systematic subtraction: identifying every element, testing what job each does, and removing what isn't load-bearing. The test is not "can this be removed?" but "does removing it break the function?" Edward Tufte's data-ink ratio applies this logic to information design; the same principle applies to every designed artefact.
Output: Inventory of elements, job each element does, what can be removed without function loss, what is truly load-bearing, and the simplified form with reasoning.