Creator of the Best Design Skill Just Unveiled His AI Design Workflow
Leon Lin's eight-step process for getting AI to produce designs that don't look AI-made, and the cook skill that runs it as a loop.
Posted
1 weeks ago
Duration
Format
Tutorial
educational
Views
145.5K
3.2K likes
57 · 43
Big Idea
The argument in one line.
Great AI-generated design comes from a structured process of references, targets, scores, and independent judges, not from clever wording in the prompt.
Who This Is For
Read if. Skip if.
READ IF YOU ARE…
You build apps or landing pages with a coding agent like Claude Code and the results keep coming out looking generic and AI-made.
You write long design prompts describing colors, spacing, and mood, and you suspect the words aren't what's getting you the result.
You want a repeatable loop you can hand to an agent so a design improves round after round without you babysitting each step.
SKIP IF…
You want a deep tutorial on any single tool shown here. The video moves fast and mostly names tools and the habits around them.
You're not building front-end designs. Every tip here is about visual quality of pages and apps.
TL;DR
The full version, fast.
Leon Lin, author of the top-trending taste design skill on GitHub, says the words in a design prompt barely matter. What matters is a process. Give the agent 9 to 12 references with a short prompt, have it build mockups as a target, set a numeric score to hit and correct its inflated self-grading, and give it hours instead of minutes. Add a ban list of AI patterns, build static design before animation, give specific feedback, and have a different agent or model judge the result against a score like 9.2 out of 10. His cook skill packages all of this into one loop.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Leon Lin's taste skill tops GitHub trending, and his article claims process matters more than description.
00:58 – 03:24
02 · Tip 1: Short prompt, strong references
Use 9 to 12 references with a short prompt. Sources include Dribbble, the inspo MCP, the awards MCP, and agent browser.
03:24 – 04:52
03 · Tip 2: Make your target first
Have the agent build three mockups on one page as a target before the real build.
04:52 – 06:45
04 · Tip 3: Set the bar with a number
Give the agent a percentage target and correct its inflated self-scoring. A demo lands near 66% of the 99% ask.
07:31 – 08:45
05 · Tip 4: Give it time
Longer runs produce very different results, paced to the usage limit, with questions asked up front.
08:45 – 10:13
06 · Tip 5: Ban the slop
A ban list of AI patterns and a slop detector skill that looks for clusters of them.
10:13 – 11:17
07 · Tip 6: Build step by step
Design with no animation first, then add motion from reference videos studied frame by frame.
11:17 – 11:41
08 · Tip 7: Specific feedback
Name the exact change, annotate screenshots, or ask the agent to describe its build.
11:41 – 12:39
09 · Tip 8: Let another model judge
Independent judge agents, ideally a different model, with a score threshold like 9.2 out of 10.
12:39 – 15:19
10 · The cook skill
A skill that packages the whole method into a loop with a brief, rounds, judges, time limit, and usage pacing.
Atomic Insights
Lines worth screenshotting.
The words you use to describe a design barely matter, because the model can't see the picture in your head and may read the same description very differently.
Leon gives the agent roughly 9 to 12 reference images with a short prompt instead of one long prompt that tries to describe the design.
A reference shows what words can't: section layout, spacing between elements, and how the type looks.
Mockups let you try many design changes cheaply because a quick webpage is far easier to change than a fully built app.
Asking for three different mockups on one page lets you pick a direction before the real build starts.
Telling the agent to hit 99% match is not realistic, but the number tells it the job isn't done the moment the page first works.
Agents grade themselves too high, so Leon tells the agent the score it actually deserves, like 60 or 70 when it claims 90.
Left alone, an agent stops as soon as the page works, which is before the page looks as good as it can.
Giving the agent 20 hours instead of 20 minutes changes the result completely, but it also burns far more of your plan.
Telling the agent to pace its work evenly over your usage limit keeps a long run from hitting the cap early and stalling.
A ban list only stops what you name. Block one AI pattern and the model slides to the next default look.
One slop pattern on a page can be a deliberate choice. A cluster of them on the same page is what gives AI design away.
Building the design with no animations first lets the agent focus, then animation gets added and tuned as a second pass.
Reference videos of animations work best when the agent writes down every movement and timing frame by frame, then blends ideas rather than copying one.
Feedback like 'make it better' gives the agent nothing to fix. Name the exact color or screenshot and circle the problem.
When you can see something is wrong but can't name it, ask the agent to describe what it built, then use its vocabulary to request the change.
The agent that built the design is the worst judge of it, so judges should start with no knowledge of how it was built.
Using a different model as judge, such as Codex reviewing Claude Code's work, adds an outside perspective plus a score the work has to reach.
Takeaway
A process beats a better prompt
WHAT TO LEARN
Design quality from an AI agent comes from references, a measurable target, time, and outside judgment, not from describing the look in more words.
02Tip 1: Short prompt, strong references
Words can be read very differently by the model, so a short prompt plus 9 to 12 references communicates the design more reliably.
References come from sites like Dribbble, MCPs like inspo (800+ sites) and the awards MCP, named apps, or agent browser studying a live site.
03Tip 2: Make your target first
A mockup is a fast webpage built from your references that lets you test design changes cheaply before the real build.
Ask for three different designs on one page, check them on small screens, then pick one and request changes in your own style.
04Tip 3: Set the bar with a number
A target percentage tells the agent the job isn't done when the page first works, even if the number is unreachable.
Agents overrate themselves, so tell it the score you think it deserves so it knows how high the bar really is.
05Tip 4: Give it time
Left alone, an agent stops once the page works. Giving it far more time changes the quality of the result a lot.
Long runs eat your plan, so ask the agent to spread work evenly over your usage limit and to ask questions up front.
06Tip 5: Ban the slop
A list of banned patterns like beige backgrounds and random fonts stops the obvious AI look, but only for what you name.
A detector that checks many slop patterns on one page works better than a single-pattern ban, since lone patterns can be intentional.
07Tip 6: Build step by step
Asking for design and animation together splits the agent's focus, so build static first and add motion after the design is right.
Reference videos let the agent log each movement and timing, then take ideas from several without copying any one.
08Tip 7: Specific feedback
Name which color or element should change, or draw on a screenshot, so the agent knows exactly what to fix.
When you can't articulate the problem, have the agent describe its layout, fonts, and colors to give you the vocabulary.
09Tip 8: Let another model judge
The builder is a poor judge of its own work, so use fresh agents with no build context and a score threshold like 9.2 out of 10.
A different model as judge, such as Codex reviewing Claude Code, or a separate terminal session, gives an independent read.
10The cook skill
Cook runs the whole method as a loop from references to brief to build to judged rounds, with a time limit and usage pacing set up front.
It keeps screenshots, side-by-side comparisons, a brief, and a rounds file with scores in one folder so each round is traceable.
Glossary
Terms worth knowing.
Taste skill
A design skill by Leon Lin that was the top trending design skill on GitHub for a while. It guides coding agents toward better looking results.
Reference
A screenshot, site, or video of a design you want the agent to match. It shows layout, spacing, and type that are hard to put into words.
Mockup
A quick, simple webpage the agent builds from your references to act as a target before the real app is built.
Slop
Visual patterns that make a page look instantly AI-made, such as beige backgrounds, random fancy fonts, and stock card layouts.
Judge agent
A separate agent, often running a different model, that reviews the work in its own context without knowing how it was built and gives it a score.
MCP
Model Context Protocol, a way to connect outside tools and data sources, like a reference library, to a coding agent.
“Leon says the words you use to describe your design barely matter.”
contrarian opener that reframes prompting→ TikTok hook↗ Tweet quote
05:22
“When you ask the agent how close it is, it gives itself a much higher score than it should.”
relatable and specific, no setup needed→ IG reel cold open↗ Tweet quote
12:07
“Leon thinks the agent that built a design is the worst judge of it.”
single clean claim with a clear reason→ newsletter pull-quote↗ Tweet quote
The Script
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
17px
Lian Lin has been the top trending author on GitHub for a while now and that's mostly because of taste skill. It's a design skill he made and it's been the top trending design skill on GitHub for a while. He also posts the things he builds on X and the designs he gets out of AI look nothing like what most people get and now he's written an article that reveals all the techniques he uses to get insane designs.
The main idea behind them is that the thing you'd think matters most is exactly what he says doesn't matter. What actually makes the design good is a structured process that you follow if this is your first time we're a software company and this is our channel ai labs and in this video we're going to go over each step of his workflow in detail then we'll show you the skill he made out of all those steps so you can repeat the whole workflow without doing each step yourself we're doing everything in cloud code but none of these tips are specific to it so they work the same way in any coding agent you use the first tip leon gives for getting good designs is to keep your prompt short and give the agent strong references leon says the words you use to describe your design barely matter that's because words don't make it clear what you actually want even if you describe the design really well the model might read it as something totally different and since the model can't see the picture in your head it can't really build the design you want that's why the references matter the most a reference shows the things that are really hard to describe like how the sections are laid out how much space there is between things and what the text looks like words alone can't explain
those as well as a picture can that's why leon says he gives the agent around 9 to 12 reference pictures with a short prompt instead of a long prompt that explains the design now there are a lot of ways to get design references for your agent one of them is dribble which is a site where designers post their work you can open it and search for the kind of app you want to build then you can look through what other people have made that matches what you want and browse through their designs once you find a style you like you can take a screenshot of the part you want on your site and paste it into your agent when you do that your agent will build that part based on the screenshot and if you don't want to do that by hand there are tools that give your agent good design references and we've covered a lot of them one of them is inspo it's basically an mcp that you connect to your agent and it gives your agent a library of more than 800 websites to use as references while it works you can connect it with the install command from its site and then it's ready to use so whenever you give your agent an app idea it will take ideas from inspo's library
build the site based on them there's also a similar tool called the awards mcp it gives your agent references from awards which is a site that picks the best designed websites you can connect it to your agent too so it can use those references and if there's an app out there that's similar to what you're building you can point your agent to it you just need to name that app in your prompt and the agent will use its web tools to look at it but if you want the agent to go through that site the way a visitor would you can use agent browser it's a tool from versal that lets the agent open any website and use it on its own it can take a screenshot of the whole page at once and it can also record a video of a site so the agent can see how the animations move to set it up you just need to run the install command from its repo once it's installed you can give your agent a site and tell it to use agent browser to study its design and build something similar when you do that it starts by opening the browser and loading the link you gave it then it scrolls through the page taking screenshots and works out the design patterns and it uses them to build its
own version and if you don't want to use agent browser any other tool that can open a site and take screenshots works too but before we move to the next tip it would be great if you subscribe to the channel and hit the hype button this small gesture of support goes a long way for us but once you have your references the second tip leon gives is to make your target first this means the agent needs a goal to reach before it builds your app so you decide exactly what the result should look like and then the agent's only job is to match that target as closely as it can.
References help a lot with how good the app will look. But before you build, you also need to know how the app will feel when you use it. A target puts all of that together quickly so you can check the whole page before the real build.
For a page, that target is a mockup, which is basically a quick version of your app that your agent builds as a simple webpage from your references. Having your agent make mockups helps a lot because you can try lots of design changes quickly without using too many tokens. That's because a mockup is much easier to change than your app once it's fully built.
And instead of copying your references exactly, you can ask for the same quality and feel in your own style so the page looks like your product. So to make your mock -ups, you just need to ask your agent to build three different designs for your app and show them all placed together on one page. Once it's done, you can look at each design and pick the one that works best for you.
And you can also check how they look on small screens so you know each design works on any device. Then whichever style you like, you can just ask your agent to build it for you.
And if you want any changes to the style, you can ask for those too and it will make them. Once your agent has a target, the third thing Leon does is set the bar it has to reach with a number. Leon says that if you just tell the agent to make the page look really good, it doesn't know how close to the target it has to get.
A number fixes that because it gives the agent something to aim for. So Leon's prompts tell the agent to match the style of the references as closely as it can and to aim for 99. Leon admits that a number this high probably isn't possible.
But the number tells the agent that the job isn't done the moment the page first works, so it keeps going after that. But a number only works if the agent scores itself fairly, and when you ask the agent how close it is, it gives itself a much higher score than it should. So Leon tells the agent what score it really deserves.
For example, if the agent says it's at 90 % and Leon thinks it's closer to 60 or 70, Leon tells it exactly that. That way the agent knows how high the bar really is.
So to put a number on your own build, you first need a reference for the agent to aim at. The reference we picked had a complex design, so we copied the site's link and asked our agent to copy that site's style for our website. Along with that, you need to tell it how close you want it to get as a percentage, and we set ours to 99%.
Once the agent has that prompt, it starts working and builds the whole design. But even though we asked for 99%, we'd say the result was only about 66 % close to what we wanted.
That's because the reference had a 3D figure at the top whose head turns to follow your mouse, and the one our agent built wasn't close at all. That's what Leon meant about a number that high not being possible. Still, the number gets you a lot further, and from here, you can keep working with your agent to get much closer to 99%.
Before moving to the next tip, let's have a word by our sponsor, MetalBear. Your agent writes code in minutes, but it writes it from static files and docs, so it has never seen your real APIs, your real schemas or the messages sitting in your queues the only way to find out if the change works is to push it to staging and wait and if it's wrong you have just broken staging for everyone else metal bear built mirror d to fix that loop it connects the code in your agent's workspace to your live staging cluster so the change runs against real environment variables real network and real traffic before it deploys only the requests from your agent's session reach that workspace so everyone else keeps hitting the version already running and nobody knows But even with a number to hit, the agent still decides on its own when to stop.
That's why Leon's fourth tip is to give it time. Leon says that if you leave the agent alone, it stops as soon as the page works, which is before the page looks as good as it can. And when the agent gets 20 hours instead of 20 minutes, Leon says the result is completely different.
So Leon tells the agent to keep working until the work matches the references. So in your prompt, you just need to mention that you want a landing page for the app you're working on. And you say that you want the page to feel like an experience, not just a landing page.
Then you need to add a line telling the agent that it can take as long as it needs, but that you need the highest quality. When you do that, the agent starts working, but it doesn't rush. Instead, it takes a really long time and uses a lot of tokens.
And with this kind of prompt the site it builds looks very different and the quality is much better but when the agent takes longer it also uses more of your plan this means you need to be careful with how long you let it run so leon also tells the agent to spread its work out evenly over the usage limit so it never runs out early and has to wait and since a long run is meant to keep going without you leon adds one more line that tells the agent to ask any questions right away and otherwise start building but a long run on its own won't stop the agent from using the same looking patterns.
So the fifth thing Leon does is ban the slop. Every one of Leon's prompts has a list of things the agent isn't allowed to use. He bans a lot of the agents usual patterns like beige backgrounds and random fancy fonts.
These are the details that make a page look AI made right away so when you name them in the prompt the agent stops using them. But a ban list only stops what you name. When you tell a model to stop using one pattern it doesn't come up with something new.
Instead it just switches to the next usual look. So you'd have to keep adding every new pattern it switches to in every prompt.
And doing that over and over gets really tiring. So we've made an AI slop detector skill that basically has a list of all the band patterns in one file. You might have seen it before because we've shown it in our earlier videos too.
It covers everything from colors and fonts to the kinds of cards and layouts that aren't allowed. And instead of giving the agent a list of band patterns every time, we use this skill whenever we're building an app. We just run it and it tells us which slop patterns are on the page we can ask the agent to fix them but the skill doesn't call one pattern slop on its own because a single color fade can be a design choice made on purpose instead it looks for a lot of slop patterns showing up on the same page it also knows all the looks that ai pages usually end up with so your agent can use it as a list of what to look out for the skill is in the ai labs design system in our community so you can get it from there and run it on your own app too so if you found value in what we do and want to support the channel this is the best way to do it the link in the description.
And once your page is free of slop, Leon's sixth tip is to build the whole design step by step. He says that instead of having the agent build the whole site with all the animations from the start, it's better to go one step at a time. That's because when you ask for the whole animated page in one go, the agent has to focus on both the design and the animations at the same time.
So what you get isn't going to be perfect. So whenever you're building a site, you first need to ask your agent to build it with no animations so it can focus. getting the design right.
Once it's built, you need to check that everything looks good and balanced, just the way you want it. Only once that part is done, you then ask it to add the animations and keep fixing those until they're right. And when it's time for the animations, Leon also gives the agent reference videos to show how the animations should move.
The agent goes through each video frame by frame and writes down every small movement and how long it takes. Then it takes ideas from all of the videos, but it never copies any one part exactly. the design and the animations, Leon's seventh tip is about how you give feedback.
It's to always give the agent something specific to change, because if you just tell it to make the page better, it has no idea what to fix. So instead of saying the colors feel off, you tell it exactly which color should change and how. Or you can take a screenshot, draw on the parts you don't like and send it back, so the agent can see exactly where the problem is.
And sometimes you can tell something's wrong, but you can't put it into words. For those times, Leon asks the agent to describe what it built.
Once it tells you how it laid out a section and which fonts and colors it used, you'll have the words for what you want to change. Then you can ask your agent to fix that exact part. Leon's last tip is to let another model judge the design you're building.
Leon thinks the agent that built a design is the worst judge of it because it made every choice in the build itself so it can't judge it fairly. So Leon uses other agents that didn't build the app to judge the work and those judges start with no idea of how the app was built. Then Leon sets a score the work has to reach, like 9 .2 out of 10, and the agent keeps fixing the work until the judges give it that score.
The judge can also be a different model from the one that built the page, so Leon sometimes asks GPT 6 .1 Sol to judge the work that Opus 5 .5 did. So if you have a second coding agent installed, like Codex alongside Cloud Code, you can ask your main agent to have the other one judge the design. And if you'd rather stick to one tool, you can ask your agent to start a separate session with a different model from the terminal and have that session review the design we also use separate review agents for most of our work because they're much better judges of it and we've covered them on our channel before but Leon's version adds a score the work has to reach and a judge from a different model now Leon turned all the steps you saw earlier into a skill so you don't have to do every step by hand the skill is called cook and it runs all these methods as a loop from design to review and to install it you can just copy the install command and run it in your terminal when you do that it asks which agent you want to install it for once you pick one you'll need to choose whether to install it just for the current project or for all your projects we installed it for the current project because that's where we want the skill to work once you answer the rest of the questions the skill is installed the skill has all the instructions it needs to run the loop it also has a script that puts its work next to your references so they can be compared and a template for the design brief to use it you just need to open which
agent you're using, run the cook command and tell it what app you want to build. When you do that, it asks you a few questions like whether you have any references and how good you want the result to be. But when it asks how much time you want it to spend, you need to give it a time limit.
If you don't set one, it'll keep running for hours and on a design build, it won't stop before eight hours by default. It also asks what your usage limits are, so you need to answer that too. This means it paces itself so it doesn't spend hours using up your whole limit on just one.
design. After you answer all the questions and give it the go -ahead, it starts working on the site. Its first step is to get design references to build against, and since we'd connected the inspo MCP, it uses that to find them.
Then it studies all the references, and once it's done, it writes a brief in the cook folder. This folder is inside your app folder, and it's where cook keeps all its work. That includes the screenshots from every round, and the side -by -side comparisons with your references.
It also has a harness folder, which is basically the set of scripts it uses to take screenshots and grade the results along with the instructions it gives the judges and it keeps the original references in the references folder as for the brief it's a file that tells the agent what its goal is and the agent writes down all its work in a rounds file along with the scores once those files are written it starts building the site for round one and when it's done it sends in the judges for that round each judge works in its own separate context window and reviews the app when the reviews come back the next round starts and the agent keeps working until the work reaches the quality bar you set.
That brings us to the end of this video. If you'd like to support the channel and help us keep making videos like this, you can do so by using the super thanks button below. As always, thank you for watching and I'll see you in the next one.
The Hook
The bait, then the rug-pull.
The thing most people obsess over when asking an AI for a design is the thing Leon Lin says matters least. His designs look nothing like typical AI output, and he laid out the process behind them in one article.
Frameworks
Named ideas worth stealing.
00:58list
Leon Lin's 8-step AI design workflow
Short prompt, strong references
Make your target first
Set the bar with a number
Give it time
Ban the slop
Build step by step
Give specific feedback
Let another model judge
A sequence for getting designs out of a coding agent that don't look AI-made, built around references, targets, scores, and independent review.
Steal forany front-end build run by a coding agent
CTA Breakdown
How they asked for the click.
VERBAL ASK
10:00product
“The skill is in the AI Labs design system in our community.”
Placed right after demoing the slop detector, so the pitch lands when the value is fresh.
Add Modern Creator as a preferred source and Google shows you more of our breakdowns in Search, Top Stories, and AI Overviews. It only changes what you see, and you can undo it in your Google settings anytime.
Add to Preferred SourcesOpens your Google source preferences with us pre-loaded. Tick the box and you're done.
AI LABS distills Anthropic's own talks and guides into nine rules for running Fable 5.2 in Claude Code: start cheaper, define done, and let Fable lead while smaller models build.
A stage-by-stage breakdown of Lauren Tan's open-source Claude Code and Cursor skill pack, measured against the other skill packs already on the channel.