How a former Apple design and engineering leader gets AI to produce world-class design

Anshu Chimala turned the exploration, critique, and pruning methods he developed while leading software engineering and design teams at Apple into a practical guide that AI agents can execute.

By Lenny's Newsletter09-02 · 18 min read

Deep Dive · XiaoHu Explains

One-minute overview

AI's next-token prediction and human preference training push design toward safe, high-probability templates with little controversy; the vaguer your prompt, the more default decisions the model makes for you.
The Discover phase uses genuinely external randomness, deliberately risky directions, and a three-step taste extraction process to first widen the candidate pool, then turn human preferences into a build brief.
In the Define phase, independent reviewers look only at screenshots and use fixed criteria to identify the biggest gaps; treat generated images and video as interface material, not as decorative afterthoughts.
The Deliver phase strips away glows, gradients, containers, and filler copy, cleans up obvious AI artifacts, and has a human rewrite key text; final sign-off checks each phase's outputs and pass conditions.

Anshu Chimala, who spent 12 years at Apple leading software engineering and design teams, published a guest post on Lenny's Newsletter about how he adapts the methods he used to manage human design teams for AI agents. He previously led teams researching and prototyping future AI products; after leaving Apple, he has continued to run product and design experiments using AI.

The three live case studies below show what this approach can realistically achieve. Each includes its task type, model, and number of prompt rounds right alongside the material—no need to imagine the results from a block of text first.

Author's diagram of AI design space, with common AI interfaces clustered at the center and bolder styles at the periphery — All images are original interactive examples and a conceptual diagram. The diagram reflects the author's mental model, not a measured probability distribution.

When Anshu publishes work like this, he keeps getting the same question: why can some people produce polished, distinctive products with tools like Claude and Codex, while others end up with nothing but purple-blue gradients, text on the left, images on the right, glassmorphism cards, and loud buttons—the familiar AI slop?

His explanation: large language models predict the most likely next token and are trained via human preference feedback to favor stable, reliable, widely acceptable choices. Design requires the model to make a continuous series of decisions about color, typography, layout, material, and spatial relationships. When the prompt provides no sharp trade-offs, each step nudges the work back toward the familiar, the safe, the average. He compares this to "design by committee": something everyone can accept, yet almost no one finds compelling.

This solution wasn't originally invented for AI. Leading teams at Apple, Anshu noticed that designers and engineers are also constrained by their existing interface experience—the moment discussions go deep, they fall back on ideas they've already built. They therefore established a stricter exploration and refinement process: first push the team to the edges of what's possible, then polish the chosen direction over and over until it's deliverable. Today, AI agents compress what once took a team weeks of exploration and production into a few hours, but someone still has to decide where to explore, what counts as good, and what to cut in the end.

The post describes this process as "loosely inspired by" the Double Diamond model. The Double Diamond is a framework from the UK Design Council for describing design and innovation processes: the first diamond diverges to understand the problem, then converges to define it; the second diamond diverges to develop multiple solutions and finally converges through testing, elimination, and refinement to a deliverable. Anshu doesn't follow the Discover, Define, Develop, Deliver stages literally. Instead, he compresses them into three phases adapted to how AI agents work:

Phase	Problem to solve	Human responsibility
Discover	Open up the candidate space; break away from default templates	Inject external variation; pick directions that feel right
Define	Develop the direction into a distinct design language	Set a quality baseline; organize agent feedback and multimedia materials
Deliver	Clean up rough edges; make the design shippable	Remove what's unnecessary; spot AI tells; rewrite key copy

None of this asks AI to "grow taste" on its own. AI handles fast exploration, implementation, and orchestration across media, while a human stays in the creative director seat: supplying variation, expressing taste, setting the quality bar, and making the final calls.

Why AI defaults to safe templates

The post runs the same "productivity app landing page" task through three conditions: a plain prompt, a prompt that only asks for randomness in language, and a third that adds externally generated random strings from the shell. Looking at the three groups side by side:

Four similar productivity landing pages, all with light backgrounds, text left, image right, and a purple button — The original examples show that candidates spread out more; they don't measure aesthetic quality, usability, or reproducibility. The SSoT study supports random strings for increasing diversity in certain generation tasks, but that's not a proxy for design quality.

Four landing pages all built around pottery and kiln metaphors, with limited stylistic variation — The original examples show that candidates spread out more; they don't measure aesthetic quality, usability, or reproducibility. The SSoT study supports random strings for increasing diversity in certain generation tasks, but that's not a proxy for design quality.

Plain prompt: Nearly all four Claude Code instances reverted to purple gradients, left-aligned title, right-side graphic, top navigation, and a prominent button. Brand names changed, but the design grammar stayed identical.
Only saying "random": Pages shifted to similar warm palettes and layouts, even repeating pottery metaphors. The model produced ideas that sound random, but without an external source of variation.
Adding random strings: Fonts, colors, light/dark values, and composition spread out noticeably; candidates stopped clustering in the same stylistic family.

Step three proves the candidate space is wider, but not automatically that aesthetics, usability, or reproducibility improved. The web experiments in the post are illustrative comparisons. Sakana AI's SSoT research validates probabilistic sampling and output diversity, not web design quality.

Discover: open the candidate space first

The Discover phase is about avoiding the temptation to dive into a single solution right away. First generate enough genuinely different directions; then narrow the space using human reactions.

Method one: give the model a truly external source of variation

Anshu borrows the String Seed of Thought idea but adapts it for coding agents: the agent first generates a long string of random letters and numbers via shell script, then extracts visual inspiration from character shapes, repeating patterns, notable digits, or structural relationships in the string.

The prompt can be structured in four steps:

Use a script to generate a sufficiently long random alphanumeric string.
Examine the string for structures that can be translated into design rules; decide color palette, typography, layout, and visual rhythm from it.
Build the page in that direction; do not fall back to common SaaS templates halfway.
The string is only for thinking; it must not appear in the final interface.

Verifiable output: At least 4 candidates for the same product, shown as side-by-side screenshots.

Acceptance criteria: Candidates should differ structurally in font category, light/dark relationships, compositional skeleton, and information rhythm. Simply swapping brand names, primary colors, or illustrations does not count as different directions.

A research boundary worth noting: the original SSoT method has the model generate a random string internally and manipulate it. Anshu's implementation instead sources the random string externally from the shell. Both aim to break default preferences, but the underlying mechanism is not identical.

The author also offers a practical long-term habit: save the bold prompts that fail today and retest them after each new model release. If a direction that previously produced broken pages suddenly becomes reliably implementable after an upgrade, that means new capabilities have entered your usable design space. Testing new models only with old prompts makes it easy to miss these shifts.

Method two: write ambition as a world that can constrain decisions

"Bolder," "more premium," "more creative" provide no visual constraints. Effective prompts offer a world coherent enough to govern an entire page, for example:

Turn the productivity tool into a continuous pixel-art game scene, with each section reading like a single frame in the game.
Organize the features as an isometric 3D city, letting neighborhoods and buildings carry the information architecture.
Use aggressive asymmetry, clashing colors, and uncomfortable negative space while keeping functionality legible.

These directions can fail, and the failure itself is useful. If an idea sounds too safe, it will most likely return the average answer from the training distribution. If it makes you wonder "can this even be done as a webpage?", that's when it genuinely forces the model to try new design grammar.

Three steps to turn AI inspiration into personal taste

Original directions can't come from "asking AI for ideas and feeding those ideas straight back to AI." Anshu uses three steps to insert human choice into the loop:

List directions only; do not elaborate. Ask AI for many one- or two-sentence concepts—brutalist tools, industrial control console, gel interface, cardboard prototype, comic-style UI. This phase exists purely to stimulate imagination.
Turn promising directions into visible results, then record your reactions. For example, an industrial control console should have the tactility and sound of physical buttons; no cartoonish or retro skeuomorphism; gray gradients feel flat—need powder coat, anodized aluminum, or fine-grain materials.
Once a direction stabilizes, have AI write a reverse build prompt. The final prompt must contain visual principles, materials, component consistency rules, prohibitions, and priorities—ready for a coding agent to produce the first POC.

Interface animation in pixel art style — Three process screenshots from the original article. Don't ask for a full page in the same round: concepts, preferences, and build constraints are three different deliverables.

AI-generated list of design concepts — Three process screenshots from the original article. Don't ask for a full page in the same round: concepts, preferences, and build constraints are three different deliverables.

Verifiable output: A design brief no longer than one page, containing at least the inspiration source, the feelings that must be preserved, explicitly rejected approaches, 3 to 5 design rules, and a set of reference images.

Acceptance criteria: A separate execution agent—one that wasn't part of the discussion—should read the brief and be able to say "what to do, what not to do, and what to build first," rather than asking follow-ups like "what do you mean by premium?"

Define: refine a direction into a design with a personality

Random seeds widen the spread, but the first batch of pages can still carry top nav, text left / image right, and a CTA button. The Define phase pushes from "somewhat different" toward "has its own identity."

Use an independent review agent that sees only the output

A coding agent struggles to evaluate its own work objectively. It carries the weight of its code structure, implementation cost, earlier decisions, and all the rationale it has already written for those decisions—it tends to keep patching the current solution.

Anshu brings in a second agent as Design Critic. Each round runs the following loop:

The execution agent finishes the current version and takes a screenshot.
Launch the review agent in a fresh context, giving it only the screenshot—no code, no implementation details, no past opinions, no defensive explanations from previous rounds.
Ask the reviewer to name the aesthetic the work is pursuing, imagine how a top design studio would handle the same direction, and point out where the gap is biggest.
The reviewer gives a score out of 10 plus a short list of specific changes; the execution agent implements them by priority and submits a new screenshot.

The post sets 9/10 as the execution agent's completion condition, but explicitly says not to write that threshold into the review prompt, so the reviewer won't loosen standards just to end the loop. The review prompt stays consistent every round, keeping scores loosely comparable across iterations.

Four designs with added randomness but similar page skeletons — The author sets 9/10 as the stopping threshold on the process side, not as an endpoint given to reviewers. Cost and efficiency numbers come from their case study, not as general benchmarks.

Long image comparison from the original article showing before and after independent screenshot reviews — The author sets 9/10 as the stopping threshold on the process side, not as an endpoint given to reviewers. Cost and efficiency numbers come from their case study, not as general benchmarks.

Review criteria can be structured in three tiers:

Weak: "Check whether it looks good and doesn't look AI." Subjective; criteria drift from round to round.
Usable: "Identify the current aesthetic direction; imagine how a top studio would execute it; compare against that quality baseline and identify the gaps."
More reliable: Provide 4 professional reference cases plus 1 current screenshot; ask the reviewer to rank them by polish and taste, and explain the ranking.

The reference images serve as a quality baseline and moodboard, not as tracing targets. Stopping conditions need care: run one or two rounds first to see whether the main issues and scores begin to converge. If two consecutive rounds show flip-flopping feedback and no score improvement, a human should redirect—not let the agent burn tokens indefinitely.

Models can be assigned by role: a faster, cheaper model handles the repetitive build; a stronger model handles the less frequent aesthetic judgments. In the examples shown in the post, Fable's review model produced less than 10% of the total tokens for each case. The author notes that letting Fable rebuild the page directly would cost about twice as much and take substantially longer. That figure only describes his cases; it is not a general budget ratio.

Push agents to call image generation directly

Coding agents naturally prefer assets they can write directly as code: gradients, geometric shapes, grids, glass cards. These aren't unusable, but when all visuals trace back to a few lines of CSS, the output tends to expose the same generative fingerprints.

The prompt in the post is direct: the current page is flat; use image generation to add character; where useful, combine generated images with shaders or 3D effects and inspect each frame in the browser.

Four interactive examples from the original article. Images, 3D, and shaders share the visual storytelling, so CSS gradients and color blocks aren't the only art direction.

Integration differs by tool:

Codex, Antigravity, or Grok Build with built-in image generation: simply instruct the agent to use that capability.
Environments like Claude Code can call Codex CLI for image generation—but confirm whether it uses subscription capacity or billed API usage.
When calling the OpenAI or Gemini API directly, create a dedicated key with a hard spending limit that can be revoked at any time.
If the agent needs to use the key repeatedly, store it in a local environment file outside the repository, and note in project rules that the key is for development only and must not ship in the product.

Verifiable output: Every visual element on the page can state its purpose: establishing space, expressing materiality, carrying character, or explaining state.

Acceptance criteria: If removing one generated image loses no information or experience, it is likely decoration. If every generated image could be replaced with a plain gradient with no loss, the visual direction hasn't been pushed deep enough.

Use video models as timeline tools

The post suggests two ways to use video for interface design.

The first is transparent looping motion: generate a looped clip on a solid-color background, then remove the background with chroma keying or a video matting model, and composite complex physics like glass shattering, spinning, refraction, shadows, or caustics into the UI. To make glass refraction credible, render the video against the page's background color first so the refraction reads naturally, then remove the background.

The second is keyframe transitions between states: generate an intermediate video from two product stills and map video progress to scrolling or gesture input. In the luggage example from the post, the sequence shows hovering, landing and opening, and items dropping in from above; the final frame of one clip continues as the starting frame of the next to reduce jump cuts.

Keyed loop animationGenerate on solid background → key out or mask → embed as an interface loop

Keyframe scroll transitionStart and end product shots → video interpolation → map timeline to scroll position

Video models handle the continuous motion; the web still handles loading, playback, and scroll control. For complex effects, prepare a first frame or poster as a fallback.

The author uses aggregation platforms like fal.ai to let agents choose between different video models. The example prompt names Seedance 2.5, which reflects a recommendation for the models available at the time—not a permanent answer.

Verifiable output: Motion files, static fallback frames, trigger conditions, and interaction mapping.

Acceptance criteria: The loop should show no obvious seams, the start and end states should be continuous, and scrolling direction should match object motion. Users must still understand the page when autoplay is off or reduced motion is enabled. Media file size and decoding cost should not compromise the first-screen experience.

Deliver: Cut, de-AI, and rewrite the copy

AI tends to keep adding and rarely deletes code on its own. In the delivery phase, the most significant work an author does is removing elements that don't add information, functionality, or state feedback.

The first draft of the calorie app had full functionality, but it also included a pink glow, gradient progress bars, randomly colored accent text, duplicate tags, large empty areas, and custom buttons and input fields that felt rougher than native iOS components.

His revision requests came down to three points:

Turn the page into a grid centered on food images.
Remove gradients, glows, and unnecessary containers.
Use native iOS controls wherever possible, and tighten font sizes, spacing, and information density.

Calorie app interface with pink glow, red progress bar, more explanatory text, and small food images — Before and after versions from the original article. The comparison shows the author's design choices, not user research or conversion proof.

Restrained beige background, less text, larger food images, and simplified controls in a calorie app interface — Before and after versions from the original article. The comparison shows the author's design choices, not user research or conversion proof.

After the redesign, food photos and the day's intake became the visual focus, with fewer colors, shorter text, and controls that feel closer to system conventions. The before-and-after pair reflects the author's design judgment, not user research or an A/B conversion test.

You can run a deletion test on every element:

If removed, does the user lose key information?
Does it take away an action or control?
Does it make the current state or next step unclear?
Does it break the most distinctive part of this design direction?

If all four answers are no, deleting is usually more effective than polishing further.

The public page places Technique 7, "Remove AI tells," behind a paywall, and Technique 8, "Rewrite the copy by hand," is confirmed through the publisher's public summary. Since no complete list for these two sections is publicly available, this article won't fill in details on the author's behalf. What we can confirm as delivery principles: humans need to review the visual byproducts added only to make something look like a tech product, and they should personally handle the copy that most shapes product tone—titles, buttons, empty states, and error messages.

Turn it into an auditable workflow

The execution order below turns the public method into a process that can be handed to a design lead and a Coding Agent:

Write clear product constraints. Document the target user, core task, must-have features, and device boundaries. The output is a one-page problem definition.
Generate 8 to 12 short directions. Go broad before going deep; reskinning the same layout doesn't count. The output is a direction list.
Inject external randomness. Use random strings on directions that lack differentiation, and generate at least 4 side-by-side screenshots.
Bring in human taste. Pick 2 to 3 directions and write down what you like, dislike, find excessive, and find missing. The output is a design brief with explicit do-nots.
Build a first POC. Have the Coding Agent implement according to the brief, without chasing production-level completeness yet.
Run independent screenshot reviews. Reviews look only at results against a fixed quality baseline; iterate once or twice first to confirm feedback is converging.
Add images and video only when understanding requires it. Every media asset must serve a purpose tied to information, material, space, or state, and must have static and no-animation alternatives ready.
Do a deletion pass. Remove elements that don't add information, action, state, or distinctiveness, preferring mature system components.
Handle copy and final acceptance by hand. Rewrite key text, then check responsive behavior, performance, accessibility, and real task flows.

Discover

External randomness, radical directions, three-step taste extraction

Output：Multiple comparable candidates plus a build briefPass criteria：Typography, palette, layout, and metaphor go beyond surface-level reskinning

Define

Screenshot review, fixed baseline, image and video generation

Output：Reviewed visual system plus rich media with fallbacksPass criteria：The largest visual gaps are closed; mobile and static states hold up

Deliver

Remove decoration, clean up AI artifacts, rewrite copy by hand

Output：Streamlined interface, human-written copy, and a delivery checklistPass criteria：Every element has a function, key tasks are clear, and AI artifacts are cleaned up

A three-stage workflow that rewrites 'having better taste' into something you can deliver, review, and stop.

The real cost of this system isn't writing a longer "magic prompt." It requires the lead to generate multiple candidates, actually review the output, articulate specific preferences, build a stable quality baseline, and finally delete code that's already done. AI provides speed in exploration and implementation; humans own direction, standards, and trade-offs.

Source

How to turn your AI into a world-class designerAnshu Chimala·2026-09-01·View primary source

Sign in