Asking an LLM for Design: Briefs, Skills, and a Process That Keep UIs from Converging on the Obvious

The problem left after the tone was right

Canary’s design team runs a flow in Claude Code that reads a PRD and generates the UI (Canary 2026). The first problem they hit while building it was that generated screens did not match the existing product’s tone. They gave the LLM their design philosophy and design guidelines as a skill, and it began to produce UIs that looked reasonably “Canary-like.” The next problem was that every screen came out as the same kind of ordinary UI.

Asked for a confirmation modal for account cancellation, the LLM, working only through the design system, returned a screen with the minimum elements the spec required. A Canary designer would add a touch of care: an explanation of what the user loses by cancelling, and the timing of the final bill and what happens after cancellation. That gap remained between a screen that is functionally correct and a screen that feels like this product.

Evaluators have seen something similar. Nielsen Norman Group gave the same redesign task to three kinds of AI tools and described the resulting screens as “flat and interchangeable” (NN/g 2025). The tools lean on default component libraries and frameworks such as shadcn and Tailwind CSS, so they produce a similar look with sans-serif type and little decoration.

The expectation that more context means less blandness fails here. With the brand guidelines, the output moved toward the brand. It still did not move away from the average.

Why does LLM output drift toward the average?

The vendors acknowledge the tendency and explain it by frequency in training data. Anthropic writes that during sampling a model predicts tokens from statistical patterns in its training data, and that “safe design choices–those that work universally and offend no one–dominate web training data” (Anthropic 2025a). OpenAI writes that when prompts are underspecified, models often fall back to high-frequency patterns from the training data (OpenAI n.d.-a).

Academic work adds the post-training stage to this explanation. Zhang and colleagues formalize typicality bias, the tendency of annotators in human preference data to systematically favor familiar text, and verify it on preference datasets (Zhang et al. 2025). A model tuned on such preferences concentrates probability on the most typical response (mode collapse). If this mechanism holds, asking the model to “be creative” meets a distribution that is itself peaked toward the typical. Zhang and colleagues report that a prompt asking for several responses along with their probabilities raises diversity in creative writing to 1.6 to 2.1 times that of direct prompting (ibid.; a preprint, and not measured on UIs).

Canary’s case can be read as consistent with this mechanism. Design guidelines narrow the range of outputs, but the tendency to pick the most typical option within the narrowed range stays. That is a plausible reason why “Canary-like” and “every screen the same” held at once.

Convergence toward the average happens not only within one output but across a population of users. In Doshi and Hauser’s experiment (293 writers), stories written after seeing one AI idea rose 5.4% in novelty, and after five ideas, 8.1%. At the same time, how closely a story resembled the average of other stories in the same condition rose by 10.7% and 8.9% of the rating scale’s full range (Doshi & Hauser 2024). Anderson and colleagues likewise showed that ideas from different ChatGPT users were semantically more alike than ideas from users of another ideation aid (Anderson et al. 2024). As more organizations use the same model with the same defaults, individual screens may get tidier while the differences between products shrink. Canary’s worry that the product would become “an ordinary product with no difference” corresponds to this population-level homogenization.

What happens when you ban the default looks?

Would it work to name the common choices and forbid them? Anthropic’s prompting guide still carries traces of that attempt. The system prompt it offers for frontend design lists fonts such as Inter, Roboto, and Arial and purple gradients on white as things to avoid, and then ends with this line. “You still tend to converge on common choices (Space Grotesk, for example) across generations.” (Anthropic n.d.-a) The vendor itself acknowledges that when common fonts are banned, generations gather on another font over time.

The revisions of the company’s frontend-design skill point the same way (Anthropic 2025b; 2026). The December 2025 version told the model to pick an extreme tone, banned Inter and similar fonts with “NEVER,” and also banned converging on Space Grotesk with “NEVER.” The current version from September 2026 names five looks that AI-generated design currently clusters around. They are a warm cream background with a high-contrast serif and a terracotta accent, a near-black background with a single acid-green or vermilion accent, a broadsheet layout with hairline rules and dense columns, identical rounded cards with the same radius and the same shadow, and template chrome that appears whatever the subject (tracked-out all-caps eyebrows, meta strings joined with middle dots, labels joined with em dashes, and so on)¹. On the first accent color, the skill notes that it is close to Anthropic’s own Claude accent, so in a user’s brief it reads as a tell. The defaults named in the 2025 version and those named in the 2026 version barely overlap. The reading that banning one default makes the next most typical choice the new default is consistent with the mechanism in the previous section.

The current version still lists typographic treatments to avoid, but its weight has shifted to three moves. The first is grounding in the subject. If the brief does not identify the product or subject, the model identifies a subject, an audience, and the design’s primary job itself, proposes them, and confirms with the client. The skill says distinctive visual choices come from the subject’s industry, materials, and vernacular. The second is calibration against defaults. The skill says each of the five looks is legitimate for some briefs but is “a default rather than a choice”; where the brief pins down a direction, the brief’s own words always win, and where the brief leaves an axis free, the model should not spend that freedom on a default. The third is a two-pass process that reviews a plan first. The model writes a short plan with 4 to 6 named hex colors, typefaces and their roles, a layout concept, and its own principles, and reviews it against the brief before building. If working through a similar prompt lands in the same place, that part is a default and gets revised.

What should the request say?

A request to an LLM corresponds to what designers call a brief. Paton and Dorst, drawing on interviews with 15 experienced designers, described briefing as a situated practice of drawing out the client’s frame and reframing it (Paton & Dorst 2011). A human designer questions an incomplete brief and reframes it. An LLM, unless told otherwise, usually goes straight to generating. In a study of turning hand-drawn sketches into web UIs, UI/UX experts also preferred models that asked them questions over passive feedback (Li et al. 2024). The frontend-design skill’s instruction to identify and confirm the subject, audience, and primary job can be read as writing that questioning into the procedure.

The brief elements named in the vendor guides overlap as follows.

The last two are where the way of writing changes the outcome. Ryo Lu, head of design at Cursor, says a person needs to specify what is good and what is right, and that without that opinion the output will be AI slop (Lu 2025). Visual references reduce ambiguity. In NN/g’s comparison, prompts with sketches, mockups, or Figma links attached produced the most accurate screens. NN/g also writes, however, that by providing these references, you have already completed much of the design work yourself (NN/g 2025). A reference also works as a pull toward resembling it. In Wadinambiarachchi and colleagues’ experiment, participants who used an AI image generator fixated more on the initial example and produced fewer ideas with less variety and lower originality (Wadinambiarachchi et al. 2024). Design fixation, in which designers carry features of an example into their own proposals, is the phenomenon Jansson and Smith demonstrated experimentally in 1991 (Jansson & Smith 1991).

A brief therefore does well to separate the axes it fixes from the axes it leaves open. Axes that should match, such as brand colors and components, are fixed through references or names. Axes where ideas should spread are left open without references, and the brief says they are open. The frontend-design skill’s rule not to spend an open axis on a default is the receiving side of this distinction.

Where should the design system do its work?

The major tools are adding ways to pass a design system to generation as context. v0 saves a design system as a skill and describes it not as a copy of the docs but as an “adapter” that tells v0 where the source lives, which components, props, and tokens are safe to use, and how to wire the system into new apps (Vercel n.d.). OpenAI gives instructions to route colors through tokens rather than hard-coding them in JSX or CSS (OpenAI n.d.-b). Figma Make has a Guidelines.md file for the rules the AI should follow, and Google’s Stitch published DESIGN.md as a format for exporting and importing design rules between projects (Figma n.d.; Google 2026). Claude Design imports a design system from a code repository or through /design-sync and has users name components (Anthropic n.d.-c). The view that the design system sets the ceiling on agent accuracy is laid out in Design Systems as AI's Foundation Layer — Structured Design Knowledge Determines Agent Accuracy.

How much to pass is a separate question. Figma writes that more context isn’t always better, that it can confuse the LLM, and that users should add only the most important rules (Figma n.d.). Conformance itself is not solved either. In a Progress survey, 36% of 225 respondents said AI results did not align with their design system standards (Progress 2025; a survey by a company that sells design-to-development tooling).

A design system is, by construction, a device that pulls output toward known patterns. What Canary questioned was where to place that device. The earlier flow went from the PRD through information architecture and then converged on UI through the design system. The new flow inserts divergence through the designer personas after information architecture and passes the drafts through the design system afterwards. When the design system applies from the start, the search tends to begin right next to the known patterns. As the Detour skill discussed below puts it, proposals found by searching nearby tend to converge on known types.

Where does divergence go, and how is it written?

Canary designs its flow so that the lead designer and the LLM follow the same steps. The human steps run from understanding requirements, to organizing the data model and information architecture, to diverging UI patterns, to reconciling with the design system, to deciding among patterns. What the LLM’s generation lacked at the time was the third step, deliberately diverging into different patterns.

In the new flow, a switch reads the requirements and PRD and recommends divergence modes, and each chosen mode produces one draft in parallel. The drafts converge through the design system’s tokens, components, and layouts, and proposals that go too far are dropped. The output is a UI and a report for each proposal. The vendor guides agree on generating several options before the final one. OpenAI recommends having the model first generate a mood board or several visual options before selecting the final assets, and the Claude Design guide says to ask for two or three options when exploring directions (OpenAI n.d.-a; Anthropic n.d.-c). Design engineer Emil Kowalski’s prototype skill builds several versions of the same UI piece so they can be switched between and compared (Kowalski 2026).

The question is how to instruct divergence. The first idea is to assign a role such as “You are an original designer.” Experiments give reason for caution here. Zheng and colleagues tried 162 roles across four families of LLMs and found that adding a role to the system prompt did not raise accuracy on factual questions, and that the effect of each role was largely random (Zheng et al. 2024). For diversity of ideas, too, the effect of role labels is inconsistent. Meincke and colleagues compared 35 prompts with GPT-4 and found cosine similarity of 0.243 for ideas from groups of humans versus 0.255 to 0.432 for GPT-4 (Meincke et al. 2024; lower means more diverse). Among role conditions, the best, “an extremely creative entrepreneur,” reached 0.348, and thinking like Steve Jobs reached 0.368, both more diverse than the 0.377 baseline, while some variants in the same family got worse, up to 0.411. The most diverse was a staged CoT prompt that asks for a short list of 100 ideas, then has the model make them bolder and more different, and finally has it write descriptions; it reached 0.255, close to the human groups.

Deng and colleagues split the reasons LLM ideas are less diverse than human ideas into two barriers (Deng et al. 2026). One is individual-level fixation, where the first outputs constrain later ones; CoT reduces it. The other is a collective-level problem: in a human population, knowledge is partitioned across people, whereas an LLM aggregates knowledge into one distribution. For this, giving ordinary personas as diverse sampling cues helps, and combining the two reportedly surpassed human diversity (ibid.; a preprint). Suh and colleagues’ Luminate also tries to avoid early convergence on a few ideas by having the model generate a design space in a structured way and letting users explore many responses within it (Suh et al. 2024). All of these were measured on ideas or text, not on the look of UIs. They still share a point: what works is not the role label but procedures that move where the search starts, and cues that split the viewpoint.

Read this way, Canary’s “designer personas” are procedures. The Detour skill is written in four sections: “1. Positioning,” “2. Design intent,” “3. Conditions for success,” and “4. Operating notes.” Its positioning is a mode that does not place the starting point of ideation near the target; because proposals found by searching nearby tend to converge on known types, the mode deliberately delays that convergence. Its design intent treats distance as a means rather than an end, handles moving away and returning to the original context as separate processes, and does not count a proposal that lacks the return as complete. Its condition for success is that the proposal can land inside the existing design rules; a proposal that cannot return is not adopted, however interesting as an idea. The Persona skill launches an agent per persona in parallel, and each re-evaluates what matters to its persona and restructures the UI. This is close to what Deng and colleagues call cues that split the viewpoint. The skill puts the differences on the side of viewpoint and keeps the output format the same. If the format varies, comparison between proposals slides into a comparison of formats. It also refuses to proceed to generation without the needed materials, and treats producing output that looks finished while still ambiguous as a heavier failure than producing no proposal. The Thriller skill pairs places deliberately left unaligned with the moment they come into alignment, and treats a proposal as invalid if the release of the tension it sets up has no clear position.

All three describe not what to produce but where to start searching and which proposals to discard for failing a condition. Canary prepares several modes because, in its words, having the model think the same way every time produces an average UI in its own way. Each mode, too, has its own typical output.

How are the proposals checked, and who chooses?

Much of the visual checking can be handed to the LLM. The Claude Code guide gives an example of verifying UI changes with screenshots: paste the original design, take a screenshot of the result, compare them, list the differences, and fix them (Anthropic n.d.-b). The frontend-design skill has the model critique its own work with screenshots as it builds, and OpenAI has the model inspect rendered pages with Playwright, test multiple viewports, and check the match with a reference UI (Anthropic 2026; OpenAI n.d.-a). These checks work when there is something clear to compare against. Examples are the difference from a reference image, a quality floor of responsiveness, keyboard focus, and accessibility, and the litmus checks in OpenAI’s frontend skill (is the brand unmistakable in the first screen, can the page be understood from headlines alone, are the cards actually necessary). Emil Kowalski’s review skill likewise has the model list problems against rules he has articulated (Kowalski 2026).

Judging which proposal is best for users cannot yet be handed over entirely. Duan and colleagues, who built UICrit, state that LLM-based UI evaluation does not yet match human evaluators; using 3,059 critiques from seven designers as examples and refining visual prompting, they improved LLM critiques by 55% (Duan et al. 2024b). In an evaluation of a system that gives GPT-4 feedback on UI mockups, the feedback helped catch subtle errors but became less useful over iterations (Duan et al. 2024a). Work on using multimodal LLMs as UI judges also reports dimensions where they approximate human perception and dimensions where they diverge (Luera et al. 2025). General issues with LLM judges are collected in Recent Currents in LLM-as-a-Judge: A Literature Map of 53 Core Studies and a Standalone Chapter on Creativity Evaluation.

Canary, too, keeps a human eye on which pattern is best for users, since that requires a different perspective. The Persona skill states that merging proposals and judging their merits are not the mode’s responsibility, and leaves the act of choosing to people.

The person choosing has biases as well. As the experiments above show, people who see AI proposals tend to fixate on the first example, and people who see proposals from the same model converge on similar conclusions (Wadinambiarachchi et al. 2024; Anderson et al. 2024). Canary’s flow, which lays out several proposals in the same format, may also work against these biases. How much the number and presentation of proposals reduce fixation when choosing among UIs, however, was not measured in the sources collected here.

How do you write a designer’s thinking into a skill?

Design knowledge goes into skills so that it is loaded only when needed. Anthropic explains that putting frontend design guidance in the system prompt would make that context follow unrelated requests such as debugging Python or writing emails, so it made a skill that loads what is needed at runtime (Anthropic 2025a).

Writing the content takes effort. At Canary, the person responsible for building the AI workflow asked the lead designer, “How did you think when you made this UI?” and took stock together over several sessions. The design process often lives in the designer’s head without being fully put into words, so they had to draw out intentions and ways of thinking by something like reverse engineering. The results were first summarized as three ways of thinking in a document shared across the design team. The LLM could not take in that document as it was, so they rewrote it as more concrete prompts and made it a skill. Emil Kowalski similarly writes that his skills are a side effect of domain expertise, something he became able to articulate after building up judgment (Kowalski 2026).

The skills collected here fall into three kinds by the step they serve.

Anthropic’s frontend-design skill holds all three in one file. Grounding in the subject and the two-pass plan sit between divergence and convergence, calibration against defaults sits on the convergence side, and screenshot self-critique and the quality floor handle inspection. Canary splits its divergence skills into one file per mode and keeps the design system side separate. In either form, it pays to decide which step a skill serves before writing it. Mixing convergence rules into a divergence skill makes it easier for even the axes meant to spread to drift back to known patterns.

A pattern from request to selection

Putting the material above in process order gives the following.

Where this does not apply

All the experiments behind the divergence techniques were measured outside UIs. Meincke and colleagues used product ideas, Deng and colleagues idea generation, Zhang and colleagues creative writing, and Doshi and Hauser short stories. Whether the same effects hold for the structure or look of screens has not been tested.

The effect Canary reports is qualitative: the probability of generating UIs with a touch of care went up. The report does not separate whether the modes’ procedures helped or the larger number of drafts did.

Vendor guides are written for specific model versions and change quickly. The frontend-design skill was substantially rewritten at least twice between December 2025 and September 2026, and the default looks it names changed. The default looks given here are as of September 2026.

The more the process diverges, the more the burden of choosing shifts to people. Three proposals mean three to compare, and five parallel modes mean five. The shift of designers’ work from making to evaluating is discussed in From Maker to Editor: A Structural Analysis of the Designer Role Transition in the Age of AI.

Finally, it is not yet known whether divergence modes like Canary’s “designer personas” will themselves become the next default once widely shared. That Anthropic’s skill counts a color close to Claude’s own accent among the defaults that read as a tell in a user’s brief can be read as an example of a choice once particular to one maker turning into a default look. Will a mode that copies a lead designer’s thinking keep that designer’s character the more it is used, or become a pattern that shows up on everyone’s screens?

Related notes

• Design Systems as AI's Foundation Layer — Structured Design Knowledge Determines Agent Accuracy: the design system as the ceiling on agent accuracy
• AI Slop: Reading It as Outsourced Verification, Not Low Quality: reading AI slop as outsourced verification, including homogenization evidence
• Vibe Coding and UI Agents: Natural-Language Production and Its Boundaries: the current state of UI generation agents
• Design Agent Tools in 2026: The Current State of Autonomous Production: agent features in Figma, Adobe, Canva, and Claude Design
• MCP and Design Systems: The Infrastructure Layer for Agent Integration: the connection layer between design tools and agents
• Activating Reframing in Design: Cognitive Mechanisms and Practical Methods: reframing and techniques against fixation
• An Academic Map of Methods for Reframing Problems: From Abduction-2 to Problem Structuring: literature on briefing and problem setting
• The Creativity of Subtraction: The Additive Bias, and the Hypothesis of Designing Absence: generation biased toward adding, and designing by subtracting
• From Maker to Editor: A Structural Analysis of the Designer Role Transition in the Age of AI: the shift from maker to editor
• Taking the LLM Smell Out of LLM Prose, and How to Bring humanizer Into This Project: techniques for reducing the LLM smell in prose
• Settling a Business App's UI on One Design: What Narrows the Options, How to Compare Them, and Who Decides: how people and teams narrow a business app UI down to one, from premises and comparison to who decides

Unverified items

No main claim is unverified. The open items in peripheral statements and in the ledgers are listed below; details are in the ledgers under source/review/llm-design-direction/.

• The abstract of Paton & Dorst (2011) was checked during collection but could not be retrieved again at writing time. [要一次検証: 取得不能 ScienceDirect 403、Crossref と OpenAlex に要旨なし]
• OpenAI’s “Designing delightful frontends with GPT-5.4” and its guides (OpenAI n.d.-a, n.d.-b), Anthropic’s prompting guide and Claude Code guide, and the v0 and Figma help pages show no publication or revision date. [要確認: 記載なし 各ページ本文]
• The publication date of Emil Kowalski’s “Agents with Taste.” [要確認: 記載なし emilkowal.ski 本文]
• Conference acceptance of Zhang et al. (2025). [要確認: 記載なし arXiv abs ページ]

References

Academic literature

• Anderson, B. R., Shah, J. H., & Kreminski, M. (2024). Homogenization Effects of Large Language Models on Human Creative Ideation. Creativity and Cognition (C&C ‘24). https://doi.org/10.1145/3635636.3656204
• Deng, Y., Brucks, M., & Toubia, O. (2026). Examining and Addressing Barriers to Diversity in LLM-Generated Ideas. arXiv preprint. https://arxiv.org/abs/2602.20408
• Doshi, A. R., & Hauser, O. P. (2024). Generative AI enhances individual creativity but reduces the collective diversity of novel content. Science Advances, 10(28), eadn5290. https://doi.org/10.1126/sciadv.adn5290
• Duan, P., Warner, J., Li, Y., & Hartmann, B. (2024a). Generating Automatic Feedback on UI Mockups with Large Language Models. CHI 2024. https://doi.org/10.1145/3613904.3642782
• Duan, P., Cheng, C.-Y., Li, G., Hartmann, B., & Li, Y. (2024b). UICrit: Enhancing Automated Design Evaluation with a UI Critique Dataset. UIST 2024. https://doi.org/10.1145/3654777.3676381
• Jansson, D. G., & Smith, S. M. (1991). Design fixation. Design Studies, 12(1), 3–11. https://doi.org/10.1016/0142-694X(91)90003-F
• Li, R., Zhang, Y., & Yang, D. (2024). Sketch2Code: Evaluating Vision-Language Models for Interactive Web Design Prototyping. arXiv preprint. https://arxiv.org/abs/2410.16232
• Luera, R., Rossi, R., Dernoncourt, F., et al. (2025). MLLM as a UI Judge: Benchmarking Multimodal LLMs for Predicting Human Perception of User Interfaces. arXiv preprint. https://arxiv.org/abs/2510.08783
• Meincke, L., Mollick, E. R., & Terwiesch, C. (2024). Prompting Diverse Ideas: Increasing AI Idea Variance. SSRN / arXiv preprint. https://arxiv.org/abs/2402.01727
• Paton, B., & Dorst, K. (2011). Briefing and reframing: A situated practice. Design Studies, 32(6), 573–587. https://doi.org/10.1016/j.destud.2011.07.002
• Suh, S., Chen, M., Min, B., Li, T. J.-J., & Xia, H. (2024). Luminate: Structured Generation and Exploration of Design Space with Large Language Models for Human-AI Co-Creation. CHI 2024. https://doi.org/10.1145/3613904.3642400
• Wadinambiarachchi, S., Kelly, R. M., Pareek, S., Zhou, Q., & Velloso, E. (2024). The Effects of Generative AI on Design Fixation and Divergent Thinking. CHI 2024. https://doi.org/10.1145/3613904.3642919
• Zhang, J., Yu, S., Chong, D., Sicilia, A., Tomz, M. R., Manning, C. D., & Shi, W. (2025). Verbalized Sampling: How to Mitigate Mode Collapse and Unlock LLM Diversity. arXiv preprint. https://arxiv.org/abs/2510.01171
• Zheng, M., Pei, J., Logeswaran, L., Lee, M., & Jurgens, D. (2024). When “A Helpful Assistant” Is Not Really Helpful: Personas in System Prompts Do Not Improve Performances of Large Language Models. Findings of EMNLP 2024. https://doi.org/10.18653/v1/2024.findings-emnlp.888

Vendor primary sources

• Anthropic (2025a). Improving frontend design through Skills. 2025-11-12. https://claude.com/blog/improving-frontend-design-through-skills
• Anthropic (2025b). frontend-design SKILL.md (version of 2025-12-04). https://github.com/anthropics/skills/blob/00756142ab04c82a447693cf373c4e0c554d1005/skills/frontend-design/SKILL.md
• Anthropic (2026). frontend-design SKILL.md (version of 2026-09-03, PR #1713). https://github.com/anthropics/skills/blob/main/skills/frontend-design/SKILL.md
• Anthropic (n.d.-a). Prompting best practices (Frontend design). https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices
• Anthropic (n.d.-b). Best practices for Claude Code (Give Claude a way to verify its work). https://code.claude.com/docs/en/best-practices
• Anthropic (n.d.-c). Get started with Claude Design. https://support.claude.com/en/articles/14604416-get-started-with-claude-design
• Figma (n.d.). Add guidelines to Figma Make. https://help.figma.com/hc/en-us/articles/33665861260823-Add-guidelines-to-Figma-Make
• Google (2025). Stitch Prompt Guide. 2025-05-19. https://discuss.ai.google.dev/t/stitch-prompt-guide/83844
• Google (2026). Stitch’s DESIGN.md format is now open-source. 2026-04-21. https://blog.google/innovation-and-ai/models-and-research/google-labs/stitch-design-md/
• OpenAI (n.d.-a). Designing delightful frontends with GPT-5.4. https://developers.openai.com/blog/designing-delightful-frontends-with-gpt-5-4
• OpenAI (n.d.-b). GPT-5.1 Prompting Guide (Design system enforcement). https://developers.openai.com/cookbook/examples/gpt-5/gpt-5-1_prompting_guide
• Vercel (2025). How to prompt v0. 2025-12-15. https://vercel.com/blog/how-to-prompt-v0
• Vercel (n.d.). Design Systems 2.0 (v0 Docs). https://v0.app/docs/design-systems-2

Research firms and surveys

• Nielsen Norman Group (Wang, H.-H., & Brown, M.) (2025). AI Prototyping in Real Design Contexts. 2025-10-24. https://www.nngroup.com/articles/ai-prototyping/
• Progress (2025). Workflows in the Age of AI (survey period 2025-09-29 to 12-05, 225 responses). https://www.telerik.com/ai-design-development-workflows-report-2025

Cases and practitioners

• Canary (varhira, 寺本裕成) (2026). ありがちなUIに収束させない生成フロー。カナリーでの「デザイナー人格」のskill化について [A generation flow that does not converge on ordinary UIs: turning “designer personas” into skills at Canary]. Cocoda. 2026-09-15. https://cocoda.design/varhirac/p/pe1f4d8e389b2
• Kowalski, E. (2026). Skills for Designers and Engineers. GitHub. https://github.com/emilkowalski/skills
• Kowalski, E. (n.d.). Agents with Taste. https://emilkowal.ski/ui/agents-with-taste
• Lu, R. (2025). Ryo Lu: Cursor, AI Turns Designers to Developers. a16z Podcast. 2025-12-16. Transcript: https://podscripts.co/podcasts/a16z-podcast/ryo-lu-cursor-ai-turns-designers-to-developers

All sources accessed 2026-09-25.

Footnotes

1. Strings joined with middle dots and labels joined with dashes are also patterns this project’s Japanese style rules forbid in running text (.claude/rules/japanese-writing-style.md). For the LLM smell in prose, see Taking the LLM Smell Out of LLM Prose, and How to Bring humanizer Into This Project. ↩