Phong Designs AI Systems

20/08/2026

"Make the spacing better." "It feels a bit heavy.

18/08/2026

The instinctive way to test a visual direction is to generate the Home screen and see if it looks good. It always looks good.

Home screens are the easiest thing in any product. Hero, a few cards, some navigation. Nothing on that screen is under pressure, so nothing about it can fail.

The direction gets proved on the awkward ones: a dense list, a long form, an error state, an empty state, a screen with almost nothing on it. On a recent booking product that meant eleven proof screens, each in both light and dark, before generating anything at scale.

Wrote up the whole thing, including why "make it modern" and "don't use Inter" fail for exactly the same reason.

You can usually tell. Something about the spacing, the card, the gradient, the particular grey.

17/08/2026

You can't hand a model a moodboard. Taste that only exists as pictures doesn't survive into anything a machine can build, and that's most of why AI-generated UI feels generic.

The complaint is everywhere now. Good colours, decent spacing, modern components, and somehow no personality. There's even an anti-AI aesthetic forming in reaction to it: grain, hand-drawn marks, deliberate imperfection.

I think the diagnosis is usually wrong, though. People blame the model's taste. I'd blame the handoff.

Here's the thing about a moodboard. It's a container for decisions that were never articulated. You collect twenty images because something in them is right, and the rightness lives in your head as a feeling. That works perfectly when you're the one designing, because you're carrying the feeling into every choice you make.

The moment a machine is producing the screens, that feeling has no route into the work. Whatever you didn't say, doesn't exist.

So there's a step in my process that people find odd: the moodboard has a hard expiry date. It's allowed to inform decisions right up to a point, and after that point it's closed and never referenced again. Everything downstream runs on words.

Before it closes, the mood gets converted into written statements. Not adjectives, descriptions specific enough to be contradicted. "Warm and modern" is useless; a model can produce a thousand different things from it and all of them are defensible. What gets recorded instead is the density, how much air sits around content, what corners do, whether shadow exists at all and what it means when it does, how loud type contrast gets between a title and its supporting line, whether imagery is photographic or illustrated and how it's treated, how motion behaves, how the writing sounds.

Written down like that, taste becomes something you can hand over, argue about, and hold a model to. Left as images, it stays a feeling that quietly evaporates at the first prompt.

There's a second reason to close the moodboard: while it stays open, there's a constant pull to copy. Reference is for extracting principles, not for lifting screens. Once it's converted into statements, the temptation goes with it, because what you're now working from is your own description rather than someone else's ex*****on.

What this doesn't solve: writing style down doesn't generate taste. If the twelve statements are vague, the output is vague, and that's on the person, not the model. And there's an irreducible bit that no description fully captures: proportion, the exact weight of one element against another. That still needs a human looking at a real screen and saying yes or no.

What do you convert your visual direction into before you prompt, or do you prompt from the images?

I've written up the full field-tested process this comes from. First comment.

16/08/2026

The tasks a junior designer used to be given are now the tasks a model does in minutes. Build out the remaining screens, apply the style across the flow, produce the state variants.

Most commentary stops at "junior roles are shrinking." The part I keep thinking about is what those tasks were quietly for.

Nobody ever assigned forty screens because forty screens needed a person. They were assigned because doing them taught you what breaks at scale, which decisions hurt later, and what wrong spacing feels like after a few hundred goes at it. Judgment built through repetition, disguised as production work.

Take the repetition away and the mechanism goes with it. So the industry now needs people with judgment, having just removed the main path by which it was acquired. That gap does not surface for a few years, which is exactly why nobody is acting on it.

Wrote up what I would tell someone starting now, what I would tell teams, and the part where I admit I got my own repetitions in before any of this existed.

The tasks a junior designer used to be given — build out the remaining screens, apply the style across the flow, produce the state variants, tidy the file — are now the tasks a model does in minutes. Most commentary stops there, at "junior roles are shrinking", which is both true and not the int...

14/08/2026

The interface looks clean. Too bad nobody can read it.

13/08/2026

Ask AI to theme your interface and one block will refuse to change. The bug isn't dark mode. You bound that block to a value instead of a meaning.

There's an ongoing argument about whether a layered token system is necessary or just over-engineering, and it's mostly being fought with opinions. I'd rather describe the consequence, because the consequence is specific and everyone who has hit it recognises it immediately.

A token system has at least two layers doing genuinely different jobs.

The bottom layer holds values. A colour, a number, a radius. It has no concept of light or dark, because it isn't a decision — it's a fact. Grey number seven is grey number seven in every context that will ever exist.

The layer above holds meanings. Surface. Border. Text on a subdued background. These do know about modes, because that's the entire point of them: one meaning, two values, and the system picks depending on where you are.

Now the failure. If a block in your interface points directly at the bottom layer, it is pointing at a fact. Facts don't change when you flip the theme. So that block sits there, unchanged, in the middle of a screen where everything else moved.

What makes this expensive is the delay. The mistake is invisible while you're building. It only surfaces the first time somebody asks for dark mode — which is often weeks later, often in a different file, often after the same mistake has been copied into fifty other places by a model doing exactly what it saw you do.

And the common fix makes it worse. You write a rule that forces that specific block to a different colour in dark mode. It looks right immediately. But you've now got an element whose appearance is decided outside the system, invisible to anyone reading the tokens, and permanently divergent. You didn't fix the binding. You hid it.

The rule I use has one sentence: colour in an interface only ever binds to a meaning, never to a value. If a component genuinely needs its own colour, that need becomes a new meaning in the layer that already handles meanings. It doesn't become a third layer, and it doesn't become an override.

This is also the single biggest thing you can do to make a model useful on a design system. Given meanings, a model can reason about intent — this is a surface, that is a border. Given raw values, all it can do is match numbers, and matching numbers is how you end up with fifty confidently wrong bindings.

What this doesn't solve: structurally correct is not the same as good-looking. A block can be bound perfectly and the dark version can still be ugly. That's a real problem with a different fix — you change the value behind the meaning, not the binding. Telling those two situations apart still takes a person looking at the screen.

Where do you land on layered tokens — necessary, or over-engineering?

I've written up the full field-tested process this comes from — first comment.

12/08/2026

Ask for a screen and you get the screen on its best day. Full of content, nothing loading, nothing failed, permission already granted, network fine.

12/08/2026

Just one more option. And suddenly the designer has option number 31.

11/08/2026

Ask AI to “make it pop,” and it thinks you are planning a New Year countdown.

10/08/2026

AI compressed the middle of my process, not the end. The last mile is still around 40% of the real work — and that's the part everyone assumes is free.

There's a contradiction sitting in plain sight right now and I don't see many people naming it.

On one side: 91% of designers say AI tools improve their work, 89% say they're faster. On the other side, the same industry is describing "production-ready" becoming the expected deliverable as a nightmare. Both are true. They're describing different halves of the job.

AI genuinely collapsed the middle. Generating screens, producing variations, drafting states, filling content — the part that used to eat days now takes an afternoon. That's real and I'm not going to downplay it.

What didn't compress is the end. Turning a set of screens into something a developer can actually build from: naming things consistently, making components that hold up, binding every value to the system, verifying the whole thing survives a theme change, wiring the flows, assembling the handoff. On my work that end section is about 40% of the effort, and it was closer to 40% before AI too. The middle shrank around it.

Which produces a strange effect. The proportion of your project that is unglamorous, precise, uncompressible finishing work has gone up, not down — even though the total came down. It feels slower at the end than it used to, because the contrast with the fast part is so sharp.

Two things follow from knowing this.

You stop misquoting. If you priced from how fast the middle now goes, you're underwater before you start. The middle isn't where the hours are anymore.

And you stop losing morale at the exact moment it matters. The stretch after the screens look good is where people burn out, because it feels like the work should be over. It isn't over. It was never over. It just used to be hidden behind a middle that took long enough to make the end feel proportionate.

What this doesn't solve: that figure is mine, from my kind of work. Small marketing sites, throwaway prototypes, anything that doesn't need to be handed to a developer — the ratio is nothing like that. I'd be careful quoting my number for your projects. But I would go and measure your own, because I suspect the answer surprises most people.

Where does your time actually go now — has anyone measured it since AI?

I've written up the full field-tested process this comes from — first comment.