Build Taste, Generate, Refine

The Taste-First Method. A three-phase workflow for designers using AI on real client work. Phase 1 makes the difference between voice-bearing output and undifferentiated slop; Phase 2 turns judgment into constraint vocabulary; Phase 3 fixes specific things instead of starting over.

Two designers hit the same brief. The first opens Midjourney and types prompts until something looks acceptable. Two hours in, she ships. The work is competent and forgettable.

The second spends twenty-five minutes building a reference grid before she opens Midjourney at all. She annotates each reference: what it teaches, what to keep, what to reject. Then she generates. Three hours in, she ships. The work has voice.

The difference isn’t talent. It isn’t tooling. They used the same generator on the same brief in the same room. The difference is process.

Most designers picking up AI spend the first months learning prompts. The faster they get at prompting, the more median their output looks. The ones who break out aren’t the ones who memorized the prompt patterns. They’re the ones who figured out that the prompt is the third step, not the first.

This article gives you the three phases that separate the two outcomes. We call it The Taste-First Method, because the first move is taste, and most of the leverage lives there.

Multiple programs have independently arrived at the same curriculum pattern: foundations on traditional craft first, AI integration in the middle, refinement and finishing at the end. The University of Europe in Berlin runs it as an MA in Generative Design and AI. RMIT and Western Sydney University build it into Australian undergraduate degrees. Shillington runs the same arc compressed into a three-month vocational bootcamp. Different institutions, different formats, the same underlying shape. The pattern is called the Sandwich Model.

We teach the same arc. Cert IV and Diploma sequence fundamentals before AI integration; Design@Work brings refinement work back over the top.

The macro pattern (a degree program, or a three-month bootcamp) and the micro pattern (a single project’s workflow) are the same shape at different scales. Taste-First is what the Sandwich Model looks like compressed into a single working day. Phase 1 plays the role of foundation: reference, vocabulary, judgment. Phase 2 is the AI integration. Phase 3 is the finishing.

That convergence matters because it points to constraint, not fashion. If multiple programs training thousands of students have arrived at the same shape independently, the shape is the answer to a real problem: AI amplifies skill but doesn’t supply it. Which means it works at the desk too.

Twenty to thirty minutes of reference gathering before any prompt is typed.

The output is a reference grid: nine to sixteen images, sorted by what they teach you, annotated with what to keep and what to reject. Three categories: anchor refs that sit closest to the target; contrast refs that are deliberately different and sharpen the target by negation; texture and material refs that handle palette and surface separately from composition.

Twenty minutes is deliberate. Less, the grid is thin and Phase 2 constraints drift. More, you stall in analysis paralysis and never start generating. Set a timer.

Annotate every reference: what aesthetic move it makes, why you’re keeping it, what you’d change. The act of writing is the act of building vocabulary. “Off-axis composition with a strong negative-space upper-left” is a phrase you can put in a prompt. “Looks cool” is not.

Skipping Phase 1 produces AI slop at scale. Generators reach for the median of their training data. Without a strong reference grid, you get the median: the same lighting, the same composition, the same colour palette, the same focal-point choice that everyone else got. With one, you can pull outputs off the median, towards specific aesthetic moves you’ve already named.

Designers without taste produce smoother slop, faster. Designers with taste produce specific work, faster. Phase 1 is where taste enters the loop.

Constrained variation under explicit constraints. Not prompt roulette.

The constraints come from Phase 1. They show up in the prompt as named vocabulary: style references, palette anchors, composition locks, negative prompts, and variation count. Each one is a knob the model can act on. (Fig-02: same brief generated with and without Phase 1 vocabulary; the side-by-side shows how the same model produces median or specific work depending entirely on what the prompt knew to specify.)

Style references are where most of Phase 1’s work pays off. Midjourney’s --sref codes, the equivalents in Imagen and FLUX, image-prompt blends: all lock visual DNA without requiring you to name an aesthetic abstractly. You picked the references in Phase 1; now they steer the model.

Palette anchors are HEX values dropped into the prompt or routed through palette-control where the tool supports it. Composition locks specify framing and aspect ratio, region prompting where it’s available, image-to-image control when you need to preserve structure. Negative prompts are as load-bearing as positive ones. What you exclude shapes the output as much as what you include.

Variation count matters more than designers expect. Generate in batches of four to eight, never one. A single output is a sample of the model’s interpretation; a batch is the distribution. You read the distribution to understand how the model parsed your prompt, then tighten the prompt or pick the batch’s best member to take into Phase 3. (Fig-03 demonstrates this with a logo brief: eight variations under the same vocabulary, ranked by how cleanly each satisfies the named constraints.)

A working test for whether your constraints are good enough: if you can’t generate eight viable variations from a single prompt, your constraints are too vague. Go back to Phase 1.

The endpoint of Phase 2 is three to five variations worth refining. Not “the final”; that comes later. Just enough material to enter Phase 3 with options.

The Zoom-In Method. You don’t re-prompt the whole image. You criticise specific elements and regenerate them surgically.

Pick the best one or two variations from Phase 2. Then write down three to five specific things wrong with each. Not “looks off.” Specific. The kerning on the title is too tight. The lower-left negative space is dead. The mid-tone in the photograph fights the type. If you can’t name what’s wrong, you don’t yet know what’s wrong, and the next generation will be a guess.

Regenerate locally. Inpaint the title region. Re-prompt the photograph with the same --sref you used in Phase 2. Adjust palette by one step on the desaturated reference colour. Each move addresses one named criticism.

Re-evaluate against the previous version, not against an imagined ideal. The question is “did the specific issue resolve, and did the fix introduce a new issue?” Not “is this perfect now?” Stop when no specific named criticism remains, not when the work feels “done.” That’s a craft judgment, not a method criterion, and the two get confused under fatigue.

Why this beats full re-prompts: full re-prompts reset the variation. The wins from Phase 2 evaporate. Zoom-In preserves what’s working and surgically fixes what’s not. That’s what designers do at the desk; tools should match the practice. Tom Johnson, an independent practitioner writing about his own AI workflow, describes the same loop almost verbatim. He calls it “creative director” mode and reaches for it for the same reason: the cost of switching the work away from poor decisions is effectively zero, so the right move is to criticise specifically and let the model fix what you named.

In our experience teaching the methodology, asking the model to review its own output before you start critiquing surfaces most of the mechanical issues you would have caught yourself: font sizes, padding, hierarchy problems, type weight that drifted across a single composition. The model fixes them without you pointing them out. Easy wins. Use them before you spend your judgment on the harder calls.

The methodology compounds across projects. Constraints you wrote in Phase 2 of one project become starting vocabulary for the next. Reference grids accumulate. The third project takes less Phase 1 time than the first because half the references already live in your library. That compounding is the difference between using AI and getting better at using it.

The clearest external evidence we’ve seen for this method comes from outside graphic design, which is what makes it interesting. Josh Armantrout, a product designer at DOSS, wrote about a Claude-assisted workflow he used to compress a multi-week prototype-discovery project into a few hours of work. The case isn’t a poster or a brand mark; it’s data-model synthesis. He’s not citing TGDS; he hasn’t seen this article. Yet his three-phase write-up reads almost step-for-step the same as ours.

His Phase 1 was reference research: he picked Thursday Boots as a hypothetical customer because they shared structural complexity with a real DOSS customer (Verve Coffee). He didn’t generate anything yet. He gathered comparable cases until he had enough material to constrain the next step.

His Phase 2 was constrained generation. He pointed Claude at the customer’s documentation and call recordings and asked it to synthesise the corpus into a structured artefact. The constraint set was exact: identify the gaps, extrapolate the data-model changes, produce a concrete plan. Specific instructions, batch output, structured deliverable. The same shape as a designer asking for eight variations under named visual constraints.

His Phase 3 was the Zoom-In Method made literal. He reported having to make two minor edits to the synthesised documents before handing them on. Two specific named fixes, not a regeneration.

We’re not citing the time figure as a benchmark; the original analysis flags it as marketing-flavoured. What holds is the shape. A trained designer, working in an unfamiliar discipline, instinctively reached for the same three-phase structure when AI joined the loop. That’s independent convergence: different surface, same underlying constraint. It shows what’s being described here isn’t a TGDS frame imposed on the work; it’s how design work goes when a trained eye is directing AI rather than being replaced by it.

The Taste-First Method is the spine of the Workflow pillar. Each cluster article goes deeper into one phase.

Phase 1 has its own treatment in Moodboarding with AI: grid construction, harvesting style codes, converting mood-boards into reusable constraint sets. That article covers the tactical details this one only sketches.

Phase 2 is Brief Writing with AI: how a client brief becomes constraint vocabulary, where to push back on under-specified asks, how to translate brand guidelines into prompt-actionable language.

Phase 3 is Design Critique with AI: the criticism vocabulary, paired-critique versus self-critique, how to use the model’s own review pass without becoming dependent on it.

The long-form worked example, a complete project run through all three phases with timing, prompts, and outputs at each step, lives in From Prompt to Portfolio, the hero piece for this section of the site.

Each of those articles can be read on its own. They’re more useful read in sequence, after this one.

The three phases map cleanly onto the four design fundamentals.

Phase 1 is colour and composition literacy. You can’t judge a reference if you can’t name what makes it work. The references that land on your grid are filtered by your eye, and your eye was trained by years of looking at design with named vocabulary in mind.

Phase 2 is vocabulary and hierarchy. Constraint language is design vocabulary in another grammar. “High contrast slab serif at 96pt with -2 tracking” is a typographic specification first and a prompt second. Designers who can name the typography produce specific outputs; designers who can’t produce median ones.

Phase 3 is critique skill. The Zoom-In Method is just the eye, applied to your own work. The model handles the mechanical issues; the designer earns the day rate on what’s left.

The thesis collapses to one line: AI multiplies skill. The methodology is how skill enters the workflow. Without skill, the three phases produce smoother slop. With skill, they produce voice.

This article exists in the Workflow pillar because it’s about how the work happens. The companion piece in the Fundamentals pillar, The Design Advantage, covers why the underlying skill matters. The two articles are siblings; read together, they cover the why and the how.

The Taste-First Method isn’t a marketing frame. It’s how working designers run AI-assisted projects when the deliverables are paid, the briefs are real, and the difference between voice and slop matters to the client.

If you’re already working freelance briefs or leading studio output, Design@Work is the structured route to applying this methodology to current client work. It’s built around real projects you bring in, not synthetic exercises.

If you’re building the design foundation this methodology runs on, Cert IV in Design is where the vocabulary and the eye get trained. The Taste-First Method needs both to multiply; Cert IV is where they get put in.

Either way, the entry point is the same: stop typing prompts first. Spend the twenty minutes on Phase 1. The work that comes out the other end won’t look like everyone else’s, because you didn’t start the way everyone else does.

Next: how Phase 1 actually works at the grid level. Read Moodboarding with AI.