Multi-Direction Concept Exploration

Module 2 ended with a brief: situation, job, direction, constraints, criteria. This module asks what happens when the right direction is genuinely not known yet — when a single brief would force a premature choice. The answer is not to ask the agent for five options in one prompt. It is to design the exploration: name the directions, run them in isolation, and converge through a comparison the team can stand behind later.

Set the framing early: agents have made breadth nearly free. Drafting three or four working concepts used to cost a week of a designer's production time; it now costs an hour or two of agent runs. What has not become free is difference — getting concepts that disagree with each other in structure rather than styling — and judgment, the decision about which trade-off the product should accept. Those two are the design work this module teaches.

Be clear about scope. The output of an exploration is a decision artifact for a design lead, not production code and not a finished prototype. Modules 4 and 5 cover holding a chosen direction to quality; this module is about choosing it honestly.

Name the failure precisely, because most people have seen it without diagnosing it. You ask for three concepts; the agent returns three layouts that share the same screen count, the same first decision, and the same hierarchy, differing in accent colour and copy tone. The reasons are structural. First, options generated in one context window can see each other — the second concept is written with the first one already in context, so it drifts towards being a variation rather than an alternative. Second, every concept is pulled towards the most common pattern in the training distribution: polished, generic, and safe. Third, the first thing on screen anchors the conversation, including any critique you ask the same agent to perform on it.

The self-critique point deserves emphasis. Asking the agent that drafted a concept whether it is any good produces agreement theatre: a positive assessment with two minor suggestions. That is not dishonesty; it is the same anchoring problem, applied to evaluation.

The consequence for the workflow: if you want directions that genuinely differ, the differences have to be designed in before generation, and the critique has to come from somewhere other than the author. That is the rest of the module.

This is the same discipline as the single-agent versus multi-agent decision covered in the school's article on using multiple design agents: more agents is not the default, it is an escalation you pay for. An exploration multiplies generation runs, adds a critique stage that cannot be skipped, and produces several documents a human has to actually read. Anthropic's engineering write-up on multi-agent research systems reports such systems using roughly fifteen times the tokens of a single chat interaction — a research figure, not a design benchmark, but the direction of the cost is not in dispute. As of June 2026 the vendor guidance says the same thing: parallel work pays off when the slices are genuinely independent, and not otherwise.

The positive cases are specific: a redesign of a core flow where the team disagrees about the approach, a structural choice such as data density or navigation model, a visual refresh with hard legal or accessibility constraints, or any decision likely to be reopened later unless the alternatives were examined on the record. The exploration's by-product — rejected directions with scores and reasons — is often worth as much as the chosen one.

The negative test is the one on the slide: if you cannot name three stances a reasonable designer might defend, the solution space is not actually open, and a single briefed run plus critique is faster and just as honest.

An axis is a dimension along which reasonable designers genuinely disagree for this product. The useful ones are structural: how much information is on screen at once, how the user moves through the work, how much is revealed up front, and what the user starts from. A direction is a committed position on one or two of these axes — not a mood board. The wireframe test on the slide is the practical check: sketch each direction's primary screen as boxes; if the boxes are the same, the directions are not different.

Tone and visual register are deliberately last. They are real axes for brand and marketing work, but for product surfaces they are the easiest way to fake difference: three skins over one structure. Use them as a secondary axis once the structural one is fixed, or in explorations whose question really is visual, such as a brand refresh.

For purely visual explorations, named style vocabularies help in the same way structural axes do — the next slide covers that. Either way, the principle is identical: difference is declared before generation, on a named axis, not discovered afterwards by squinting at the outputs.

This slide grounds the stance idea in something shipping in the wild. Huashu Design — an MIT-licensed, HTML-native design skill for coding agents with around fourteen thousand GitHub stars as of mid-2026 — includes a direction advisor for exactly the situation this module covers: the brief is vague and the style is undecided. It maintains twenty design philosophies grouped into five schools (information architecture, kinetic poetry, minimalism, experimental avant-garde, and an eastern-philosophy school), and when triggered it recommends three philosophies drawn from three different schools, generates demos for them in parallel where the agent supports subagents, and lets the human pick one or mix.

The transferable mechanism is not the specific taxonomy — your product probably does not need 'kinetic poetry'. It is the determinism. Drawing the three candidates from three different schools guarantees spread by construction rather than hoping the model varies. And each named direction carries committed characteristics — palettes, type choices, density rules — which makes it checkable later: a reviewer can say this draft broke its own direction's rules, which is a far stronger critique than this feels samey.

For your own explorations, the equivalent move is the stance paragraph from the workflow this module is built on: a one-paragraph design position each direction must commit to, with its characteristics stated. Naming is what makes the difference enforceable.

The structure does two jobs at once. The shared part — user, job, constraints, brand rules, anti-patterns, and the scoring rubric — is identical for every direction, which is what makes the outputs comparable later: every direction answered the same question under the same rules. The stance is the only thing that differs, and it is a commitment, not a suggestion. The drafting instructions tell each agent to commit fully to its stance even where it creates trade-offs, and to name those trade-offs rather than hedge towards the middle.

Walk the example briefly: an onboarding redesign with a hard legal constraint (data residency before content creation) and an accessibility floor. The three stances differ on structural axes from two slides ago — navigation model and starting point — and each is something a reasonable designer might argue for in a real meeting. That is the bar for a stance.

Also worth stating: each direction asks for a direction package, not a finished design — a concept statement, the screen-by-screen structure, key interaction decisions, what the direction deliberately sacrifices, a rough effort note, and open questions. A consistent package format is what lets the comparison stage line them up. In a prototyping context you can add a thin working prototype per direction, but the package is what gets compared.

Walk the diagram left to right. The brief and stances on the left are human work — that is where the design thinking happens. The middle column is the fan-out: one drafting agent per stance, run in parallel, each given only the shared brief and its own stance, each writing its package to its own file in a scratch folder. The isolation is the load-bearing part: because no direction sees another, they cannot converge on each other, which removes the structural cause of sameness from slide two.

The convergence column is the adversarial critique stage. Every direction is reviewed by agents that did not write it, each arguing against the direction it reviews — its job is to find where the direction fails the brief, not to balance praise and concerns. The output is the comparison board: rubric scores with evidence, the strongest objection per direction, constraint violations (which disqualify rather than score), blend candidates, and open questions. Deliberately, no winner.

Mechanically, in Claude Code this runs well as a dynamic workflow: an orchestration script fans out drafting agents, waits, fans out critics, and returns only the comparison report to the main conversation, keeping intermediate drafts out of the shared context. Saved to .claude/workflows/ it becomes a reusable command. But the pattern survives on any platform — separate sessions or subagents per direction, separate output files, and a scripted or checklisted critique stage all achieve the same isolation. Scratch naming matters too: one folder per exploration, one file per direction, named by stance, so the merge step knows exactly what it is reading.

The rubric is written by the human, before generation, and it ships inside the brief so every direction knows how it will be judged. Five to seven criteria is usually right — short enough that a design lead can hold it in their head while reading the comparison report. The weights encode what the product actually values for this decision; if the weights are wrong, the workflow will efficiently rank directions against the wrong standard, which is a human failure the agents cannot catch.

Two rules carry most of the value. First, evidence is required for every score: the critique must cite the direction package or the brief, which is what separates a comparison from a vibe. Second, constraint violations disqualify rather than score low — a direction that puts content creation before the legal data-residency step is not a 2 on constraint fit, it is out, or it goes back for another pass.

The comparison report built from these scores has a fixed shape: the score table with one-line evidence, the strongest objection per direction taken from the critiques, the constraint check, named blend candidates, and the open questions a human must settle. It is built for a decision meeting, not for reading cover to cover. And scores are comparable within one run only — do not compare numbers across different briefs or different runs.

The convergence step is where explorations most often go soft. The comfortable move is to declare that all three directions have merit and ask for a blend of the best of each — which produces a committee design: a structure that nobody proposed, that inherits the compromises of all three, and that no critique ever examined. The discipline is to choose one direction as the structural spine and then transplant only named elements from the others, specifically the blend candidates the comparison report called out. In the brand-refresh case from the source workflow, the chosen direction borrowed its colour system from an eliminated one — a named transplant, not an average.

It is also worth saying that the safe-compromise direction often loses on the evidence. In the data-density case study, the hybrid with a density toggle — the option everyone assumed would win — took the lowest weighted score, because three separate critiques showed it doubled the design and QA surface for every future feature, and its own package admitted the toggle existed because the direction would not commit.

Finally, the record. Write down the decision, the reasons, and the rejected directions, and keep them next to the packages. That single page is what stops the decision being relitigated in a quarter, and it is the artifact that makes the whole exploration cheaper the second time, because the stances and rubric get reused.

Presentation is where an honest exploration can quietly become a rigged one. The most common distortion is uneven fidelity: one direction got an extra hour of agent polish, or happens to use real data while the others use placeholders, and the room anchors on it before a word is spoken. The fix is procedural — every direction is built with the same component library, the same data, and the same time budget, and anything that cannot be equalised is named out loud.

The second distortion is leading with screens. Show four screens before stating the stance and the trade-off, and the conversation becomes about which one people like, which is the hallway opinion this module exists to replace. Lead with what each direction commits to and what it sacrifices, then show the screens as evidence for that position, with the comparison board visible.

Third, keep the recommendation and the evidence separable. It is fine — usually right — for the design lead to walk in with a recommendation, but stakeholders should be able to see the scores, the objections, and the open questions independently of it. And the fidelity honesty from Module 1 applies here with extra force: every direction prototype fakes things, and the things they fake should be the same things, stated on the slide, so nobody mistakes a more complete fake for a better direction.

This trace comes from the school's published multi-direction exploration workflow; the timings are from that run, not a benchmark, so quote them as indicative. The setup is the brief from slide six: a B2B onboarding redesign, 41% completion, a hard legal constraint on data residency, and three stances on the navigation and starting-point axes. Drafting the three direction packages in parallel took about 22 minutes; the full critique matrix — each direction reviewed by two non-authors — took another 15.

Walk what the critiques actually found, because this is where the structure earns its cost. The guided-linear direction won on job completion but its critics showed the legal step inflated it to eight screens. The single-page direction looked cheapest to ship, but two separate critiques flagged that its disclosure pattern hid the teammate invitation — the step the team's own data tied most strongly to retention. The template-first direction drew the decisive objection: templates implied creating content before the data-residency choice, which is a constraint violation and therefore disqualifying rather than a low score.

The convergence followed the rules from slide nine: guided linear as the spine, the template gallery transplanted in as the final step, two optional screens the critique had marked low-value cut, and a one-page decision record kept next to the packages — including why template-first lost, which is the answer to the question someone will ask in six months.

Like the earlier exercises in this course, the first pass is deliberately on paper, because the failure modes are all upstream of the agent: an exploration that was not needed, stances that are really one stance, a rubric that rewards the wrong thing. The first bullet matters most — the honest answer for many tasks is that a single briefed run is enough, and writing that sentence is a legitimate completion of the exercise.

If the task does deserve it, the stances are where to spend the time. Push participants towards structural axes and the wireframe test; the most common weak submission is three stances that differ only in tone. The rubric should be written before looking at any output, and it should include at least one disqualifying constraint, because that is what gives the critique stage teeth.

For those who run it: keep the whole exploration in a scratch folder per Module 1's disposability rules, run the drafting agents in isolation, and do not skip the critique stage even if one direction looks like an obvious winner — the obvious winner losing on evidence is a recurring outcome in real runs. Bring the comparison board and the decision record to Module 4: the chosen direction is the design that the parity work there will hold the implementation to.

Recap by connecting the mechanism to the failure it prevents. Convergence is structural, so the fixes are structural: directions drafted in isolation so they cannot pull towards each other, stances named in advance so difference is committed rather than hoped for, and critique assigned to non-authors so the evaluation is not anchored on its own draft. The comparison board exists so the decision is made on criteria and evidence; the human decision and the written record exist because the scores are inputs, not the answer.

Restate the cost honesty: this is an escalation, not a default. Most prototyping tasks in this course are single-direction and are better served by the brief-and-critique loop from Module 2. The exploration earns its multiplied runs when the decision is expensive, contested, or likely to be reopened.

Then set up Module 4 concretely. The exploration ends with a chosen direction — a package, possibly a thin prototype, and a decision record. Module 4 is about the next discipline: when the design now exists, holding the implementation to it. That means a parity setup with the reference and the implementation side by side, screenshot evidence rather than assertions, the spacing and state details agents reliably miss, and an iteration loop that converges one named gap at a time. If participants ran the exercise, the direction they chose is the reference they will use.