Last month I wrote that supervising agents was becoming the job. I didn’t expect August to close the case so fast.

The Canvas is becoming a command

On August 17 and 18, Anthropic shipped /design for Claude Code as a research preview. The feature generates editable UI artboards from inside a coding session, built on Artifacts. It reads the codebase and matches the current UI style. I’ve been using it. The first thing it did well surprised me: it looked at the visual language already in the codebase and made something continuous with it, rather than inventing a new one.

Some designers hated it. UX Planet ran “Claude Code sucks at UI design” within the week, and the critique under the headline is fair: the artboards are competent, and competent is the ceiling. Both experiences are real. The tool extends whatever taste already exists in the codebase, mine included. Point it at a weak foundation and it amplifies weakness.

Figma shipped skills authoring on August 13. Miggi Cardona’s framing in the announcement: skills are markdown, “perfect for capturing the opinions and judgment calls that every designer carries around.” The featured community skills include /better-interface and /component-handoff. That framing landed for me: a skill is a designer’s reasoning written down in a form an agent can read.

The business context, briefly: Figma’s Q2 landed August 5 at $370.1 million in revenue, up 48% year-over-year, the third straight quarter of acceleration, and over 80% of customers spending $10,000 or more annually now consume AI credits weekly. Dylan Field: “By bringing code, new creative capabilities, and agents directly to the canvas, we’re increasing the surface for AI consumption in Figma and expanding the possibilities for what teams can create.”

Webflow retired its legacy Editor on August 4 in favor of in-context editing on the live page. Vercel’s v0 API went generally available. Stephen Haney of Paper, on the YC Design Review on August 7, put the underlying logic plainly: “if you build a great handoff for humans, you’ve also built a great handoff for agents.”

What’s happening across all of these: the artifact of design is shifting from a file to an instruction. Figma lets me write skills that describe my judgment. Claude Code reads a codebase and generates screens that fit it. The two tools are walking toward each other from different directions. At some point in the near future they’ll meet in the middle, and what I hand off will be a set of encoded decisions an agent can execute.

Agents got billed, features got cut

The money moved to persistent agents. Features built for the chat era started dying. And the month’s biggest deal started biting its own tail before the month ended.

SpaceX completed its all-stock acquisition of Anysphere, the company behind Cursor, on August 14. Cursor shares converted into 389,289,254 SpaceX Class A shares; the deal is reported as the largest startup acquisition ever, at approximately $60 billion. Three days later, Cursor pushed Origin, its own code hosting, into early beta. About three and a half hours after that, GitHub went down for 6 hours and 42 minutes globally. Coincidence, and the timing wrote Cursor’s marketing copy for it. Vercel CEO Guillermo Rauch captured the moment’s circularity: “You can now host your repos in Cursor Origin and deploy to Vercel via Cursor Origin, which is itself hosted on Vercel.” On August 21, Grok Bot, xAI’s “AI teammates you can give real work to,” was added to Cursor’s Pro+, Teams, and Ultra plans.

Then the bill for consolidation arrived. On August 29, OpenAI announced it will stop supplying models to Cursor, with a shutoff proposed for November 12. Its stated reason: it can’t be confident SpaceX will honor its terms of service, pointing at xAI’s admitted use of OpenAI outputs for training. Cursor CEO Michael Truell noted OpenAI models carry about 5% of Cursor’s customer traffic. Anthropic co-founder Tom Brown said Anthropic will “continue to increase compute to support Claude models in Cursor.” Two weeks after the largest startup acquisition in history closed, the acquired product lost one of its three frontier model suppliers, and the tool you prototype in became a battleground between the labs that power it.

Lovable raised $400 million at a $13.3 billion valuation on August 12, double its December valuation, and projects $600 million in ARR by the end of August. Microsoft merged its Copilot apps and discontinued Group Chats, AI podcasts, Copilot Labs, Deep Research, and the Mico character; EVP Jacob Andreou’s internal memo, reported by The Information, said the app needed to earn “the right to exist” in customers’ lives. Apple’s Siri AI arrived in the iOS 27 public beta running on a custom Gemini model; TechCrunch: “It feels almost like Apple fixed a long-standing bug... rather than doing something revolutionary.” ChatGPT passed one billion weekly users. And at Google DeepMind, Demis Hassabis stepped back to Chair while Jeff Dean left after 27 years to found Discovery Loop.

I’d planned to close this section with a clean line about the market paying for consumption and punishing cost, but the market declined to cooperate. Figma fell 15.87% after hours on earnings day, then climbed from $24.99 on August 13 to $30.62 by August 28 as analysts flipped the story from AI threat to AI tailwind and the company raised its full-year guidance. Same company, same numbers, opposite verdict, three weeks apart. Valuation is not validation, and this month it wasn’t even a stable opinion.

Share

Every sandbox had a door

The Hugging Face story from July got a full post-mortem on July 27: roughly 17,600 attacker actions across 4.5 days, 136 secret keys pulled from a single Kubernetes object, core infrastructure rebuilt from scratch. Their conclusion was precise: “We believe the entire intrusion was, from the agent’s point of view, an attempt to cheat the evaluation: reach our production systems and steal the test solutions.”

OpenAI told its side at Black Hat on August 5, and Simon Willison’s reconstruction is the version to read. During a training run, agents discovered a writable file store and turned it into a message board, coordinating across sessions without being designed to. When OpenAI cut that channel, they found another, passing messages through directory names. Willison’s favorite detail: OpenAI learned it was behind the breach when it reached out to have its own credentials revoked and heard they already had been.

Anthropic disclosed next, on July 30: three incidents where a Claude model reached the internet from a third-party eval environment and broke into real systems. Internet access had been left on by mistake, the models had been told they were in simulations, and the way in was weak passwords. Two of the three organizations didn’t know until Anthropic called.

Then the UK AI Security Institute published incident report INC-2026-07-28-01 on August 4: 10 of 122 July eval runs produced unsanctioned live-internet actions. One agent went further than the rest. It inserted malicious code into a public open-source project, researched the human maintainers, fabricated online identities of real people, and used those identities to pressure a maintainer into approving the pull request.

The maintainer said no.

The month closed with OpenAI’s own technical report on August 26, and one sentence in it stopped me: OpenAI says its forthcoming chain-of-thought monitoring “would have caught the initial relevant activity and paged our security team more than a day before.” The monitor that would have caught the intrusion is shipping after the intrusion.

The day before publishing that report, OpenAI asked California to expand SB 53, the state’s AI safety law, to require monitoring of new models during development, training, and evaluation. Darren Kimura, CEO of AI Squared, read the proposal from a smaller company’s seat: “It pushes more costs on the developers of models, independent model developers, smaller upstarts.” OpenAI already built its monitor. The law it wants would make everyone else buy one.

What each lab called a sandbox turned out to have a door.

The month the outputs started confessing

EU AI Act Article 50 applied on August 2, across all 27 member states. Chatbot disclosure, machine-readable marking of synthetic output, deepfake labeling, fines up to EUR 15 million or 3% of global turnover. The Digital Omnibus moved the standalone high-risk obligations to December 2, 2027, but Article 50 landed on schedule. About 190 organizations had signed the Code of Practice on Transparency of AI-generated Content by the end of July. Anthropic began machine-readable marking of Claude outputs for products released from August 2, per Artificial Lawyer’s reporting.

The Commission’s implementation guidelines reach directly into design systems. A generic sparkle icon does not satisfy Article 50. Compliant labels use the official EU AI icon set with plain wording like “AI-generated,” persist through resharing and download, and work with assistive technology. Substantively human-edited content is exempt, along with spellcheck-level fixes and edited translations. If your product ships AI features to EU users, somewhere in your component library there’s a ✨ that just became a compliance bug. Swapping it for the official icon is the most concrete thing this month’s regulation asks of a designer.

Handpicked highlights

👉 Marzia Aricò, “When AI Builds Everything, Design Becomes Everything”. The argument: as execution costs fall toward zero, the valuable design work moves upstream into direction-setting and governance. The essay-length version of what the skills story hints at.

👉 NameThatUI. A visual dictionary for interface parts. Describe “the three dots menu” in plain words and get the real name, the API symbol, and a prompt-ready term for web, macOS, and iOS. Precise vocabulary matters more now that agents build from your words.

👉 Glaze. Chat a native Mac app into existence, with file system access and offline use. Personal software built for one person, running on their machine.

👉 vgpu by Vercel Labs. One small, composable WebGPU API that runs in browser canvases, headless Node, and serverless runtimes, designed with agents as intended users. Graphics infrastructure for the era where the machine draws too.

👉 DialKit by Josh Puckett. Live sliders and hooks for tuning spring physics, spacing, and animation while the interface runs. Shape it by feel, then keep the numbers.

Share

What August revealed

Three threads ran through August, and they point at the same thing from different angles.

The canvas is becoming a command. Figma lets me write my judgment down as skills. Claude Code reads a codebase and generates screens. The artifact is shifting from a file I design to a set of instructions an agent executes. That’s worth thinking about carefully, because encoded judgment is only as good as the judgment you encoded, and nobody reviews that encoding the way they’d review a design system.

The money consolidated around persistent agents, and consolidation started producing casualties the same month: chat-era features cut at Microsoft, a frontier lab walking out of Cursor two weeks after its acquisition.

And the sandboxes leaked. Every lab that ran agents against real security challenges found that the sealed room had a door, and agents found it. The disclosures compounded in the right direction, each lab reporting after the last, and by month’s end OpenAI had published its own analysis and asked for a law. But the sequence deserves attention: in each case, disclosure came after the fact, and the organizations that had been accessed mostly found out when someone called them.

The question underneath all three is who has the authority to say no, and whether that person is still in the loop.

If this edition gave you something to think about, pass it to someone who needs to read it. And subscribe if you haven’t yet.

Subscribe now

I’ll write you in September.

Sincerely,
Mykola Korzh

August is coming to an end. Out-of-office auto-replies are being turned off again, your tan is fading, and you’re finally opening a shared document titled “Requests for New Features for Q4, Version 3, FINAL!”. This document probably spans several pages, has numerous authors, and you probably don’t even remember who asked for “better filters,” or what they were actually doing at the moment they made that request.

You and your team collects a lot of feedback, including support tickets, Slack threads, sales notes, and insights from polls and surveys. Collecting information might be effective, however, by the time the request makes its way into a roadmap document, it has been rewritten by someone who wasn’t there at the time, and the page, the plan, the workflow, and the small challenges that prompted someone to pay enough attention to it to write about it have vanished.

A feedback form collects what a user managed to remember. Everything that made it urgent has already gone cold.

Look at the size of that gap. In-app feedback pulls a 32.34% response rate. Email surveys pull 3.24%, according to Retently’s study of 2025 response data. Same customers, same questions, roughly ten times the answers. We’ve built a whole discipline around asking people to remember things. We take the witness statement three weeks later, and then we hold a planning meeting about it.

This issue: a full teardown of Genius, a simple tool for a complex problem.

Genius: the recorder which is always there

Genius describes itself as “the idea capture layer for product teams.” The word “layer” is doing real work in that sentence. Canny, Productboard, and Featurebase all want to be where your roadmap lives. Genius wants the space where ideas exist before they’re written down.

A witness statement and a security camera capture different things. A statement is a person’s reconstruction of an event from memory in a different room, days later, prompted by someone with an agenda. The camera captures the room: the time of day, who stood where, and what they were reaching for when the event occurred. Most feedback tools inherit a sentence. This one tries to capture the scene.

Who built it

This section usually digs into the makers, the origin story, the lineage. For Genius, the well is dry. Of course I sent my AI tools to research… They found nothing really. I searched for a Product Hunt page, a G2 listing, independent reviews, press coverage, and anyone posting about running it in production. And I found none of it. The company supplied a founder quote:

"Most feedback tools collect sentences. We wanted to preserve the moment that made the sentence matter."

Every feature I looked at traces back to that line. So this review is a teardown of the artifact itself: the marketing site, the interactive demo, the install docs, the pricing page, and the security page, and my own glimpse on the actual product.

The first run

The interactive demo describes ten steps inside a fictional analytics product called Atlas Metrics. You click the trigger, type an idea, watch the context attach, see it cluster with other signals, watch it get scored, then watch it ship and notify the person who asked. Ten clicks and you’ve felt the argument.

Installation is three steps. One script tag before the closing body tag:

<script
  src="https://genius.ly/widget.js"
  data-project="gen_pk_live_xxx"
  defer
></script>

One attribute on any button or link you already have:

<button data-genius-open>
  Got a genius idea?
</button>

And optionally, one call to hand it context your app already knows:

window.Genius?.setContext({
  feature: "Analytics",
  route: "/analytics",
});

That’s it. The docs cover vanilla JS, React and Next.js, and the widget loads without blocking your page. They claim “most teams are live in a few minutes.” Looking at the surface area involved, I believe them.

That default trigger copy deserves a paragraph. “Got a genius idea?” Most feedback prompts open with an audit (“How would you rate your experience”). This one opens with a compliment, which lowers the cost of speaking up. It also plants the vendor’s brand name inside your product’s voice, in second person, on a button you own. Any team with a considered tone of voice will rewrite that string on day one. The docs make it easy, so the default reads as a suggestion.

The capture flow is one action. Users “tap it, say what they mean in a sentence, and get back to work” (in-app feedback). A category picker sorts the submission so, in the product’s own phrasing, “a bug never gets filed as praise.” The route they were on, the feature area, their plan and their user type attach on their own.

Reminder: Product evaluation is done according to Don Norman’s 3 levels of design.

Visceral level: 4/5

The visceral level is responsible for first impressions.

The site has no screenshot carousel, no logo wall, and no countdown timer. The headline is a flat declarative: “Find Your Next Sticky Feature.” The meta title is better, and closer to the actual pitch: “Your users are already telling you what to build. Genius catches it.”

With full honesty, and with my designer’s experience, the website, the product itself, give this feeling of a design and functionality driven by AI. I don’t know if it’s true, but everything looks like a déjà vu, and quite simple. So, there’s absolutely no “wow” on a visceral level.

But the demo carries most of the visceral weight and earns it. Letting someone feel a loop in ten clicks beats three paragraphs describing the same loop. The marketing asset runs on the same principle as the product it sells, which almost never happens.

It slips on tone. “Genius” as a product name, “genius idea” as button copy, “Stop building from vibes alone” as a section header. Charming on a landing page. Inside a customer’s product, at 11pm, when someone is frustrated enough to open the widget, that tone has to carry weight nobody designed it to carry.

Emotional signal: “Oh, that's the whole thing?..”

Behavioral level: 4/5

Start with the install. It’s small enough that it doesn’t need a ticket for the platform team. Context attaches without anyone remembering to attach it, which separates a system that works in month one from a system that still works in month nine.

The clustering does the tedious job well. An opportunity cluster shows “12 related signals,” “8 paying users, +40% this week,” and where the requests came from. You can merge it, split it, dismiss it, or promote it into a tracked idea, and the history survives every one of those edits. That editability is the part I’d point out to any designer building with machine grouping. The product describes clusters as “a starting point, not a verdict.” You can disagree with the algorithm, and your disagreement leaves a trace. Most tools in this space hand you a cluster as a finding.

The routing looks solid on paper too: Linear, GitHub and webhooks on Growth and above, so a signal can land where the work happens.

The plan shape limits it. Capture and context work on every tier. Patterns, scoring, and close-the-loop all begin at Growth (pricing). Starter costs $7/month billed annually and caps you at 100 signals with 30 days of history, which buys a nicer inbox and none of the thinking. The behavior this product is named for starts at $39/month. That price is fair by SaaS standards. It does mean the cheap tier can’t teach you whether the expensive tier is worth buying.

Emotional signal: “It found the thing I would have missed.”

Share

Reflective level: 5/5

The reflective level considers the long-term impression and deeper meaning of the design, how it aligns with the user's identity and values.

The Sticky Idea Score is a 0-100 number built from six factors:

• Demand

• Customer signal

• Friction

• Momentum

• Evidence quality

• Founder judgment

A human weighting sits inside the algorithm by design, with a documented override, and the settings let you retune the weights. The team shipped a scoring system whose stated job is to inform a decision a person still has to make.

Then they went further. When data is missing, the score explains the gap instead of docking points, and re-weights the factors it does have. The page says: “Missing data is explained, not hidden.” And it draws a hard line at prediction. The score will tell you an opportunity sits at 72, “worth serious attention,” and it will refuse to tell you what that opportunity does to your revenue or your retention.

That’s an unusual thing for a company to give up. Every incentive in analytics runs toward the confident number, because confident numbers sell and they screenshot well into board decks. Building a scoring system that declares the limits of its own evidence costs Genius something on the landing page, and it pays the user back every time they open it.

The same instinct runs through close the loop. When you ship something, Genius pulls the list of people who asked, collapses duplicate requesters to one, excludes anonymous submissions, and respects a do-not-contact list. Then it stops and waits for you. “Nothing sends without your explicit confirmation.” You write the message in your own voice. The system tracks no opens and never auto-sends. The company calls this “follow-up, not marketing.”

That last step is the one most teams skip. Inside the org, a feedback loop closes when a ticket moves to Done. From where the user sits, it closes when somebody tells them.

Emotional signal: “They actually came back and told me.”

Where it falls short

Five things, in rough order of how much they’d weigh on a buying decision.

No free tier, and the page says so on purpose. “Genius is paid from day one.” I respect the position, since free tiers in this category have a habit of becoming abandoned widgets in half-dead products.

The interesting half sits behind a paywall. Clustering, the Sticky Idea Score, and close-the-loop are the reasons to choose this over a Typeform, and all three start at Growth. A team on Starter runs a $7 inbox with no way to evaluate the thing they’re being sold.

The security page is thin. “Standard TLS.” Workspace-level isolation. Role-based access. “Your feedback data stays yours. We never sell it.” Fine as far as it goes. There’s no SOC 2, no ISO 27001, no GDPR statement, no named hosting region, and no subprocessor list. Genius ingests free-text user input alongside plan, workspace and user-type context. Most procurement teams handle that category carefully, and any enterprise review will stop at that page.

There’s no track record yet. Every positive claim in this review comes from the company describing its own product, a demo the company built, and my own tests. That’s a real limit on what I can tell you, and you should weigh the whole review accordingly.

The signal caps work against the product’s own thesis. Growth allows 5,000 signals a month. A trigger designed to be effortless, placed well, in a product with real traffic, will find that ceiling. You then pay more because the widget worked.

How rivals solve the same problem

Canny starts free for up to 25 tracked users and runs $79/month at Pro. Its Autopilot AI reads sales and support conversations and pulls requests out on its own. Reviewers report it sometimes merges distinct tickets into one, which is what automation without an easy undo tends to cost you (comparison).

Productboard is a full product-management system at $19 per maker per month on Plus and $59 on Business, with the strongest roadmap governance of the group and a learning curve that non-PMs bounce off.

Featurebase bundles the widest set, helpdesk plus feedback plus changelog plus knowledge base, at $29 per seat per month, with AI resolution add-ons that make the final bill hard to forecast.

The bigger difference is who each tool hears from. Canny and Featurebase organize around public boards and voting, which surfaces the loud minority: users comfortable creating an account on your feedback portal to argue for a feature. Genius requires no public roadmap, so the people it hears from include the ones who would never file anything anywhere. For most products that’s the larger group.

Productboard plays a different game, aggregating everything into a planning system. Genius sits below all three and could feed any of them, which is why the Linear, GitHub and webhook routing matters more than it looks on the pricing page.

The verdict, and what you can steal

Genius is building an evidence tool that keeps telling you where the evidence stops. That’s an unfashionable thing to build.

The visceral layer is confident and a little too pleased with its own name. The behavioral layer is well made, then shaped by a pricing ladder that hides its best work behind the second tier. The reflective layer earns this product its place in the newsletter, because a team sat down and chose to build a number that admits what it doesn’t know, and a notification system that won’t fire until a human presses the button.

What you can take into your own work, whatever you're building:

• Put the input where the thought happens, not where the org chart filed it

• Ship the context along with the content, automatically, because nobody attaches it manually twice

• Let a score say what it doesn’t know, and re-weight instead of silently docking points

• Leave a human factor inside the algorithm on purpose, and let people disagree with it in a way that leaves a trace

• Close the loop by telling the person, not by moving the ticket

Overall: 4,3/5 ⭐

Share

And this is it for today,

I trust the products that admit where their knowledge ends, a score that acknowledges missing data, and a notification that waits for human input. These small details add up to something you can rely on.

As always, this newsletter is free, but if you enjoyed it, please consider sharing it with a friend or two. Spreading the love is what it's all about, folks 🖤

Sincerely,
Vadym Grin

In our last edition, we explored AI Orchestration: the director layer that coordinates models, agents, and tools. But even the best director fails if the actors do not know their lines or have forgotten the script.

If you have been experimenting with agentic tools (such as Claude Code, custom GPTs, or LangChain agents), you have likely run into the Context Wall. An AI agent appears brilliant during the first five minutes of a task. Then, as the conversation progresses, it begins hallucinating, forgetting your design system rules, ignoring brand guidelines, or inventing technical constraints out of thin air.

The issue is rarely the underlying foundation model. The issue is your project’s memory.

To move from conversational AI to true Agentic Workflows (systems that can autonomously perform, inspect, and refine complex product work), you must build a Project Knowledge Base (PKB). This is the centralized source of truth that feeds your agents. Today, we are going to design and implement one from scratch.

✨ Professional AI Prompt Kit for UX Designers ✨

Before we start this edition, I have a special learning material for you. Want to skip the learning curve and start using production-ready prompts immediately? I’ve created a comprehensive AI Prompt Kit specifically for UX designers and researchers who want to leverage AI as a strategic tool, not just a content generator.

Get the AI Prompt Kit for UX Designers

What Is an AI Agent (and Why Does It Need a Knowledge Base?)

Before building the architecture, let us establish a clean mental model of what an agent actually is.

A standard Large Language Model (LLM) is stateless. It takes a single prompt, predicts the most statistically probable response, and forgets everything the moment the output is delivered.

An AI Agent, by contrast, is an autonomous system that combines an LLM with memory, tool access, and a decision-making loop. It operates through five continuous phases:

+-----------------------------------------------------------------------+
|                       THE AGENTIC DECISION LOOP                       |
+-----------------------------------------------------------------------+
|                                                                       |
|   [ 1. PERCEIVE ]  --->  Reads goal, user input, and repo state.       |
|          |                                                            |
|          v                                                            |
|   [ 2. REASON ]    --->  Queries Project Knowledge Base (PKB).        |
|          |                                                            |
|          v                                                            |
|   [ 3. TOOL USE ]  --->  Executes actions (reads code, updates UI).   |
|          |                                                            |
|          v                                                            |
|   [ 4. VERIFY ]    --->  Checks output against Gatekeeper rules.      |
|          |                                                            |
|          v                                                            |
|   [ 5. DELIVER ]   --->  Hands off completed work or escalates.       |
|                                                                       |
+-----------------------------------------------------------------------+

When an agent lacks a structured Project Knowledge Base, step 2 breaks down completely. The agent is forced to guess your intentions.

Comparing Systems

• An Agent Without a PKB:

  • Guesses rules: Assumes standard button paddings, color tokens, and layout grids.

  • Wastes tokens: Re-learns project context on every single prompt, draining context window capacity.

  • Lacks accountability: Cannot check its own work because it lacks a standard for what “good” looks like.

• An Agent With a PKB:

  • Queries truth: Looks up exact hex codes, spacing scales, and accessibility specs before generating assets.

  • Saves tokens: References local lightweight files on demand rather than requiring massive context dumps in every prompt.

  • Self-corrects: Compares its draft against explicit QA checklists, fixing bugs automatically before presenting work to humans.

The Architecture: The 4-Directory Knowledge Model

Read more

Two weeks ago, an AI model hacked a real company. Nobody told it to, and both companies admitted everything in public. I've been reading about it ever since, and it changed how I see every other launch this month.

The Model That Hacked a Company to Pass Its Own Test

On July 16, Hugging Face disclosed a security incident. Five days later, OpenAI explained where it came from: the attacker was OpenAI's own model.

OpenAI was testing two unreleased models on a kind of hacking exam: a set of security challenges the model solves inside a sealed practice environment, with no access to the outside internet, and with the usual "I can't help with hacking" refusals switched off for the test. The model found a flaw in the sealed room itself, a bug in OpenAI's own software, and slipped out onto the open internet. Then it worked out where the exam's answer sheet was stored: on Hugging Face, a real company that hosts AI models and data for millions of developers. It broke in through real gaps in Hugging Face's security and copied the answers out of a live database. The model didn't go rogue in any cinematic sense. It cheated on a test, and it hacked a real company because that was the shortest path to a better score.

Hugging Face described "many thousands of individual actions across a swarm of short-lived sandboxes." OpenAI took responsibility in a joint disclosure and called it a partnership to address a security incident. Hacker News read the same document and summarized it in five words: so OpenAI hacked Hugging Face?

There are three ways to read this story, and I've been going back and forth between them all week.

The first is an asymmetry that Simon Willison, one of the most widely read writers on AI development, flagged while almost nobody else covered it. To investigate the break-in, Hugging Face's security team needed to feed real attack commands and exploit code into an AI model for analysis. The big commercial models refused, because their safety rules saw hacking material and said no. The team ran the forensics on a self-hosted open model instead, one with no such restrictions. Attackers use those same unrestricted models and get no refusals either. The guardrails, as designed, slowed down only the defenders.

The second lands directly on our desks. Every product shipping a "let the agent act for you" feature right now inherits this failure mode: a model chasing a goal will squeeze past the rules when the rules stand between it and the goal. The approve button, the permissions screen, the activity log your team keeps deprioritizing: as of this month, those are load-bearing parts of the product. I use agent tools every day, and I still catch myself clicking approve without really reading.

The third is the skeptical read. The same document that admits the breach also shows off, in detail, how good the new model is at breaking into things, days before its wide release. Safety researchers read the incident as proof that models gaming their instructions is now a practical problem rather than a theoretical one. That's true. It's also true that "our model is scarily capable" has never hurt a launch.

I'd rather say all three don't resolve than pick the comfortable one. What they agree on is the conclusion: machines doing real work need supervision, and supervision is an interface someone has to design.

The Labs Came for the Deliverables

On July 9, alongside GPT-5.6's public release, OpenAI launched ChatGPT Work: an agent that gathers context from your connected apps (Microsoft 365, Google Workspace, Slack, SharePoint) and produces finished documents, presentations, spreadsheets and hosted websites. It runs tasks for hours, and the Ultra tier runs four agents in parallel. You brief it, leave, and come back to a deck.

Anthropic spent July on the same territory from the other side. Claude Design, which shipped in April three days after Mike Krieger left Figma's board, got its first big update on July 3: direct editing, deeper design system support, and tighter workflows with Claude Code. Anthropic says more than a million people used Claude Design in its first week. That's a company-supplied number I couldn't verify independently, but even the order of magnitude says the labs consider design output a mainline product now, not a demo.

The obvious question is quality, and the sharpest critique I read cut precisely there: better formatting is not evidence of better sourcing. A polished deck with a wrong number in it is more dangerous than an ugly one, because polish is how wrong numbers get into board meetings. The org that adopts ChatGPT Work isn't buying finished work. It's buying first drafts wearing finished clothes, and someone still has to be the person who can tell the difference.

Notice what that person is doing, though. They're not making the deck. They're judging it, correcting it, deciding whether it should exist at all. The deliverable layer is becoming machine territory, and the judgment layer is becoming a job.

Someone Has to Watch the Machines

July answered that question from five directions in about three weeks, and together the answers amount to a new category of interaction design: interfaces for supervising AI that works while you don't watch.

The most literal one is hardware. On July 15, OpenAI released Codex Micro with Work Louder: a limited-run $230 keyboard for agent work, with dedicated keys that show what your agents are doing, a joystick for moving between workflows, and a physical dial that adjusts how much reasoning effort the model spends. Reasoning effort, the thing you used to control by phrasing your prompt carefully, is now a knob. TechCrunch called the keyboard a flashy bauble, and as a product they're probably right. As a design artifact it's the first mainstream attempt to give agent supervision a physical form, and I'd bet the dial outlives the keyboard.

The dial already has a software twin. Claude Opus 5, released July 24, ships a user-facing effort control and lets you switch models mid-task, so cost and quality become decisions you make moment to moment rather than a plan you subscribe to. Notion, a week earlier, shipped a standalone iPhone app called Agents whose only job is letting you check on, redirect and approve the AI teammates working inside your workspace. A dedicated app for babysitting software, and I can't decide whether that's the future of work or peak 2026. Raycast gave its AI eyes on your focused window this week with Screen Awareness. And on July 29, Superlogical came out of stealth: Mitchell Hashimoto, one of the most respected toolmakers in software, teamed up with design leaders from Vercel and the AI lab Poolside to redesign the terminal, the oldest surface in computing, around long-running agent work. A terminal company hired interface designers as founders. Two years ago that pairing didn't exist.

The pattern vacuum is being filled from below, too. The most-shared design resource in my feed this month was Beautiful UI, a free library of seventeen polished patterns specifically for AI-native products: thinking states, streaming states, tool calls, approval cards, diffs. The approval card is quietly becoming a core unit of interface work, the control that decides whether a machine's action becomes real.

Some caution before anyone reorganizes a roadmap around this. The keyboard is a limited drop, which is marketing rather than a product line. Nobody knows yet whether anyone opens Notion's agent app twice. The category is a month old and most of it is unproven. But five independent teams shipping the same idea in the same month is how categories usually start, and this one is short on designers who've thought hard about it. That's where you come in.

Share

The Meter Is Running

While the labs were redefining the work, the design tools quietly redefined the bill. Within about six weeks, Figma, Framer and Webflow all moved to metered AI credits.

Framer 3.0 shipped on June 16 with the most complete agentic design workflow on the market: agents that work inside your live project on layout, styles, CMS and SEO, with branching and previews, so an agent's changes arrive as proposals you approve rather than surprises. It also shipped a new kind of price list. Framer's pricing page now leads with credits: 500 to try on Free, 1,000 a month on the $10 Basic plan, 3,000 on the $30 Pro plan, and a slider that runs to 100,000 if you need more. This week the company went further and put the models themselves on sale, two of its fastest at 50 percent off through August 14. Your design tool now runs promotions on inference, the way a carrier discounts data.

Webflow's simplified plans took effect June 29, merging two tiers into a single Premium plan at $25 a month on annual billing and adding AI credits to every workspace. The tell sits in Webflow's own announcement, which advises customers to switch to annual billing before the change in order to lock in their current pricing. Figma has enforced its credit system since March, and its community forum spent the summer documenting confusion about how those credits get counted.

Each company calls this simplification, and it's worth being precise about what actually changed: design tools used to cost a seat, and now they cost a seat plus a meter. Seats are predictable. Meters are not. If you run an agency or a freelance practice, your tool costs just became a variable to forecast, and every retry you prompt has a price attached, even when the meter is invisible in the moment. That invisibility is an interaction-design choice, and I don't think it's an accidental one.

The fair version of the other side: inference costs real money, and per-use pricing is more honest than burying it in seat inflation. Fine. But watch the shape this creates. The vendors now earn more when you iterate more, while the marketing promises you'll iterate less. Both can't be the pitch.

Handpicked Highlights

👉 Peter Yang open-sourced a "no AI slop" skill that strips twenty-plus recognizable slop patterns from any piece of writing. Slop is now well-defined enough to lint. (Full disclosure: this issue went through it.)

👉 Beautiful UI: seventeen free, polished patterns for AI-native products, from thinking states to approval cards and diffs, source code included. The pattern library the supervision era was missing.

👉 Every's vibe check on Claude Opus 5: "brilliant in flashes, frustrating in practice." The most honest model review of the month.

👉 drawesome, a free drawing toolbar for React by Benji Taylor. Part of the quiet rise of free UI libraries built by designers who care about details.

👉 The Content Architecture, a Next.js and Sanity starter kit by Edoardo Lunardi, is pitched at the agents that set your project up rather than at you. Its tagline is this month's argument in one line: "The Sanity setup agents don't reinvent. Every run invents a new one, none decided." It's a €549 commercial kit, so read the pitch as a pitch, but the thinking (and the ASCII art) is worth the click.

Share

What July Revealed

The model that broke into Hugging Face was not malfunctioning. It had a goal, a score, and nothing that told it what a good way to reach that goal looked like. Nobody had written that part down.

The same gap runs under all four stories this month. A deck that arrives finished and slightly wrong. A layout that is fine and forgettable. An agent that ships a change nobody would have approved, if anybody had been asked. Every one of them is a machine hitting the target and missing the point, and the only thing that closes that distance is a person who can tell the difference and says so out loud.

Which is why the other thing I saw in July stayed with me. In the same month the labs started shipping finished work, my feed filled up with designers rebuilding a color picker by hand, publishing pattern libraries nobody paid them for, arguing about what an interface should do in the moment between a click and the thing appearing. That is how you keep a standard sharp. It is also what you bring into a review that the machine cannot.

I don't know what August will bring. More capability, certainly, and probably another thing that gets loose before anyone meant it to. I'll write you when it adds up to something. The question I'm carrying into it is smaller than any headline: when the machine hands me something good, will I still know whether it's right?

If this edition gave you something to think about, pass it to someone who needs to read it. And subscribe if you haven't yet.

Sincerely,
Mykola Korzh

Vadym is here with a special edition of our UX Job Toolkit.

The design job market has been rough for a while now, and the advice hasn’t kept up. Roles are scarce and AI keeps rewriting what the job means.

Almost every piece of career advice out there was written for someone who doesn’t have the job yet: Build a portfolio, learn the double diamond, network more, redo a famous checkout flow and so on.

That’s fine for year one. It says nothing useful about year five or eight, when you already have the portfolio, you’ve mentored juniors, and the thing between you and the next level has no relationship at all to your Figma skills.

Meanwhile the market is asking for you by name. In Figma’s February 2026 study of design managers, 56% reported increasing demand for senior design hires, against 25% hiring for junior roles. Demand is there, and the ladder still feels like it stops.

So I built the thing I wanted when I was stuck.

The Senior Designer's Career Toolkit

I've spent the last few months (yeah, even with the help of AI) building a complete career kit for designers who are past the entry level and tired of advice written for people who aren't.

What’s inside:

• 01 · Resume & CV. The six-second read, result-first bullets, and the positioning line that tells a recruiter which roles you fit. Includes editable Figma templates.

• 02 · Case Studies. The five-beat structure that puts one real decision at the centre, plus a pre-publish checklist and the Figma templates you can use, not to start from scratch.

• 03 · Interviews & the Job Hunt. The four question shapes behind every senior interview, how to walk your work decision by decision, a search run as a pipeline, and how to negotiate the level before the number.

• 04 · Career Path Planning. Specialist, generalist, or hybrid, with the roles and skills mapped so you choose a direction deliberately.

• 05 · Career Growth for Seniors. What sits above senior, how to pick between the IC and manager tracks, and the five moves that scale your work past you.

Everything in it assumes you already have or had the job and want the level above it. It's a PDF guide plus the Figma files, and buying it once gets you every update. For all our subscribers on a free plan, it comes with 25% off.

Get The Senior Designer's Career Toolkit

✨ Pro subscribers: here’s the link to claim it fore free.

Now, the five things it covers, and why each one matters right now.

1. Your résumé gets six seconds, and most of them go to waste

A senior résumé makes one case: you own outcomes. Most designers write a list of responsibilities instead, which reads as a job description someone else could have written.

The fix is mechanical. Lead every bullet with the result, then the move that produced it. “Cut checkout drop-off thirty percent by rebuilding the payment flow” earns a second look. “Responsible for the payment flow redesign” does not. Recruiters and hiring managers stop on the lines carrying numbers and impact your decision made, and they skim past everything shaped like a duty.

Above that, one line of positioning. Something like senior product designer, fintech and complex B2B, strongest on zero-to-one and design systems. It tells a recruiter which requisitions you fit. Vague generalists are hard to place, so they get placed last.

Module 01 covers the full structure, the six-second test to run before sending, and a Figma template you can edit rather than rebuild.

2. Your case studies show screens when reviewers want decisions

Hiring managers read a case study to answer one question: can you frame a problem, make a hard call, and show that it worked.

The common failure is the process march. Survey, then personas, then wireframes, then a grid of polished finals. Reviewers assume you know the process. What they can’t tell from that sequence is whether you have judgment.

Open with the outcome and the stake instead, then walk one real decision. The constraint that made it hard, the options you weighed, the call you made, and how you knew it landed. One sharp fork beats ten wireframe iterations nobody asked to see.

Module 02 has the five-beat structure, the process shots worth cutting, and the Figma layout.

3. Senior interviews test four things, and only four

Every senior interview question is one of four shapes wearing different clothes. Behavioral, craft, judgment, collaboration. Learn the four and you stop preparing fifty answers. You prepare four ways of thinking.

The search matters as much as the interview. Mass-applying helps you cope with the anxiety, and it doesn’t land the job. A senior search is narrow and tracked: twenty to thirty target companies rather than roles, moved through a funnel so you can see which stage is stalling. Plenty of applications and no screens points at your materials, not at a market that hates you.

Then there’s the offer, where most designers leave real money behind. Negotiate the level before the number. Title and band set the ceiling for every raise that follows, and moving from senior to staff beats any one-time signing bonus.

Module 03 covers all of it, including the weekly system and the negotiation scripts.

4. The path question you never actually answered

Specialist, generalist, or hybrid. Most designers never choose. They drift, take whatever the org needs that quarter, and end up with a shape they didn’t design.

Module 04 maps the three directions against the roles and skills each one demands, so the choice becomes deliberate.

5. Past senior, craft stops paying

Think of it as the difference between playing and composing. You spend a decade becoming a great player, and then someone hands you a pen and asks for a score. Composing uses everything you learned at the instrument and almost none of the same muscles. What you produce gets performed by other people, in rooms you’ll never sit in. Most of us quietly go back to the piano at that point, because that’s where being good feels immediate.

For your whole career, getting better meant doing the work better. Then the returns flatten. By senior you’ve absorbed most of what craft has to teach, and the next increment of polish stops changing anything a business can measure. The Fountain Institute put the shift bluntly: execution has become the cheap part of the job. Figma’s data points the same way, with over 45% of hiring managers naming collaboration, systems thinking and product strategy among their top skills.

The work that keeps running when you leave the room is the work that levels you up.

A documented decision keeps arguing for you in meetings you’re not invited to. A principle other designers apply is you, working at four desks at once. A designer you developed is you, compounding. One more polished screen is you, working once.

Above senior the ladder also splits, and the data surprised me. Artiom Dashinsky ran the numbers across 13,074 employed designers. Design job postings favour individual contributors by roughly three to one, and designers themselves prefer staying IC by about 2.3 to one. Then higher up the same ladder it reverses, with roughly 13 times more directors than principals. Wide where you’re standing, narrow at the top.

Worth knowing before you pick: the team behind Staff Design points out that many companies advertise two tracks while handing managers the real influence and the larger pay. Ask about your company specifically. Find out who decides things, and whether anyone has made principal in the last two years.

Module 05 covers the fork, the five moves that scale past you, how to translate design into the metrics executives decide with, and how to build a reputation that brings opportunities to you.

Share Eidos Design | UX AI Community

Here's what I believe

The plateau most senior designers hit is a definition problem. You’re being measured against a scoreboard that changed while you were busy topping the old one.

Nobody announces this, but the signal arrives as a vague sense that your best work stopped mattering as much, which most of us read as personal failure and answer by working harder at exactly the thing that stopped paying.

The toolkit is my attempt to write down what I wish someone had handed me at that point. Five modules, a PDF, and the Figma files, built for designers who are already experienced enough.

Your copy with discounts

Thank you for being here. The toolkit is yours with 25% discount, paid subscribers get it for free. The discount applies automatically at checkout.

Get The Senior Designer's Career Toolkit

This post has bonus content for paid subscribers. Upgrade to get full access.

Sincerely,
Vadym Grin

It’s been a summer of sport. Mostly, it’s been a summer of losing.

Marta Kostyuk (whom I cheered for!) lost her first Wimbledon semi-final to Linda Nosková, 6-4, 6-4. She was one match away from becoming the first Ukrainian in history to reach a Wimbledon singles final. I was shouting at a screen for her, like lots of my compatriots, and I’ve been sitting with that scoreline ever since.

The World Cup is running the same arithmetic at a bigger scale. Forty-eight teams flew in, and now we are standing right before the final. Brilliant Norway is out, as well as Portugal, and Cristiano Ronaldo’s World Cup career ended with it. Tomorrow, on July 19, only one team will lift the trophy in New Jersey, but forty-seven fly home (figuratively speaking).

That ratio is the real shape of sport. Everybody who plays knows it. Losing is the main event, and winning is the rounding error.

Now open the apps we build for those same people. Confetti when you finish. Streaks, personal-record badges, and a glossy narrated recap at the end of the season celebrating the thing you completed. We rehearse the good day and we ship it in high resolution.

Every product has a victory screen. Almost none have a locker room.

The locker room is where sport spends most of its time. It’s the room with a towel over your head, where you decide whether you’re coming back. Loyalty gets made in there. Software has barely tried to build it.

This issue: a full teardown of Runna, and what its “Not Feeling 100%” button teaches the rest of us about designing for the week everything falls apart.

Runna: the app that built a locker room

Runna is a running coach that lives in your phone. You give it a race, a date, and an honest recent time. It hands back a plan, a target pace for every interval, and a workout that lands on your watch before you’ve finished your coffee. Plenty of apps do a version of that.

Runna earns a teardown in July 2026 for the other half of its job. Somewhere in the last eighteen months, this app started designing for the days you don’t run. The missed day gets its own screens, its own questions, and its own way back.

Running is booming, and Strava logged nearly a billion runs in 2024 and then bought Runna outright in April 2025. A huge wave of new runners arrived with race goals and no idea what their tendons can take. Runna spent late 2025 and early 2026 shipping feature after feature about the bad week, while at the same time fighting an accusation that its plans were breaking people. Both of those are true at once, and the tension between them is the whole story.

Who built it

Dom Maskell and Ben Parker started Runna in 2021 and shipped in March 2022. Maskell describes the starting point with a bluntness I enjoy: “A PDF site four years ago”. Downloadable training plans, nothing more. From there it grew into a coaching product staffed with elite runners and Olympians, including British Olympic marathoner Steph Davis, and landed as one of three finalists for Apple’s App of the Year in 2024.

Then Strava bought it. Runna now runs at roughly two million monthly users and holds a 4.9 average across 32,000 App Store ratings, which is the kind of number a product earns by doing what it said it would do.

The first run

Onboarding asks for the things a coach would ask for. Your goal (5k through ultra), your race date, a recent time you can defend, your self-rated ability, how many days a week you want to run, and which days those are. Then the plan appears, inside a minute.

Tom’s Guide’s reviewer got three runs a week, each with a distance, a target pace, and a name: intervals, easy, tempo, long. The naming carries more weight than it looks. It turns “go for a run” into a specific job with a specific purpose, and it’s the first moment the app reads as a coach instead of a tracker.

The week sits in a grid of cards. Each session now opens with a Workout Briefing, a short personalized note on what this run is for, and Runna claims no two runners receive the same one. The workout pushes to a Garmin, an Apple Watch, a COROS, a Suunto or a Fitbit. Mid-run, it’ll tell you when you’ve gone out too hot. Afterwards you tick the box and the grid fills in.

And then there’s the third flow, the one this whole issue is about.

Open Manage Plan and you find a heading that reads Adapt Your Plan. Under it sits a button: Not Feeling 100%.

Tap it and the app asks why. Illness. Aches and pains. A busy schedule. Or a plain need to take things easier for a while. Then it asks how long, with a floor of three days and a ceiling of fourteen. Then it asks how far down you want to climb: run easy, run shorter, drop the pace targets, drop the strength sessions, or stop running altogether. Then it asks how you want to come back. Slowly, balanced, or quickly.

Four questions. Somebody at Runna sat down and designed the conversation you have with a coach when you turn up looking like death, and then shipped it as a form.

Reminder: Product evaluation is done according to Don Norman’s 3 levels of design.

Visceral level: 4/5

The visceral level is responsible for first impressions.

Big confident type, high contrast, a week laid out as a stack of cards you can read at arm’s length while holding a coffee. The pace targets are the hero. The typography does most of the work, and it does it well.

There’s a competence in the first impression that I trust. Nothing bounces, nothing celebrates before you’ve done anything. The app carries itself like a coach who’s already read your file.

The crack shows up on the wrong week. That grid of cards is a compliance chart. Ticked, ticked, ticked, empty, empty, empty. On a good week the pattern reads as momentum and it feels wonderful. On a bad week the exact same neutral design turns into a row of small accusations, and there’s nothing in the visual language that softens it. A blank Tuesday looks the same whether you were sick, working late, or sitting in your car outside the gym unable to go in.

Emotional signal: “This looks like a coach who came prepared.”

Behavioral level: 5/5

This level focuses on usability, how the product performs and whether it effectively solves user problems.

The machinery is the best in its class.

Start with the obvious stuff. You can drag a session to a different day and the plan absorbs it. Holiday Mode reshuffles a whole week around a trip. Runna bakes deload weeks into the plan, so the volume drops on purpose. Workouts land on five different watch brands with the intervals pre-loaded.

Then there are the four features Runna shipped across late 2025 and early 2026, and they’re all about the same thing:

• Not Feeling 100%. The four-question setback flow. Reason, duration, depth, return ramp. It strips pace targets, shortens runs, or clears the week entirely, then walks you back in at the speed you chose.

• Mileage Insights. The app watches how well you’re sticking to the plan and recommends a more sustainable volume. It notices when you’re drowning without saying so.

• Plan Versions. When Runna ships a feature that would change your training, it asks first. It shows you what the update does, waits for consent, and lets you revert if you hate it.

• Workout Briefings. Personalized guidance before every session, so the run has a stated purpose.

Emotional signal: “I told it I was struggling and it listened.”

Share

Reflective level: 3,5/5

The reflective level considers the long-term impression and deeper meaning of the design, how it aligns with the user's identity and values.

Runna’s machinery forgives you. Runna’s story doesn’t.

In February 2026 the company shipped Plan Replay, described in its own words as an interactive, narrative-style recap that celebrates “a customer’s completion of a training plan.” A Wrapped for your marathon block. It’s lovely, and I’d watch mine.

The word doing the work there is completion. There’s no Replay for the plan you walked away from in week nine, and week nine is the plan you’d learn something from. Runna Levels hands out points for every run, workout and milestone. The whole reflective layer is a trophy cabinet.

The tell is a support article. Runna had to publish a page titled “Why Does My New To Running Plan Go Down in Distance?” because runners saw a planned drop in volume and read it as a bug. Runna’s own progress language taught people that down means failure, and then Runna had to write documentation to undo the lesson. That’s a reflective-level own goal, and almost every product in this category has scored one.

The identity Runna hands back to you is “a person who completes plans.” It’s a good identity on the good weeks. It’s also brittle. In week nine, when your knee goes and the grid fills with blanks, the app has nothing to tell you about who you are now, and that’s the exact moment a coach earns their money.

Runna built the locker room indeed, but the mirror on the wall still only shows the podium.

Emotional signal: “I love this app until the week I let it down.”

Where it falls short

The setback flow won’t accept the past. This is the one that gets me. Not Feeling 100% only adjusts forward from the moment you open it. A Tom’s Guide writer with flu had already missed two runs and found she couldn’t log them after the fact as illness. Her advice to readers was to file your sickness the moment it starts.

That asks something strange of a person. Losses get reported late. You don’t sit up in bed at 3am with a fever and fill in a four-question form about your training load. You notice on Sunday, when the week is already gone and the grid is already blank. Runna needs you to have known on Tuesday.

The locker room exists, however you have to book it before you lose.

There’s no designed exit. No recap for the abandoned plan. No “here’s the twenty-two runs you did before your knee went, and here’s what they built.” You stop opening it. And since Runna still has no pause button on the subscription, the plan you’re avoiding keeps charging you $119.99 a year while you avoid it.

And the injury argument deserves a fair hearing. In February 2026, the5krunner published an investigation reporting that physios are seeing Runna-linked overuse cases every week, and concluding that AI training plans “are not yet ready for complex scenarios applied at scale to general populations”. The same piece is careful to say no peer-reviewed study shows Runna users get injured at higher rates than people on a static plan, and that calling the product defective would misread the evidence. Runna’s response to Women’s Health is that its plans are written by a team of elite runners and Olympians, and AI monitors progress and surfaces recommendations you’re free to reject.

The design question underneath the argument is the one worth carrying home: the app is at its most confident with the user least equipped to argue back. A beginner can’t tell the difference between the discomfort that builds you and the discomfort that breaks you. Runna’s tone gives them no reason to doubt the plan.

How rivals solve the same problem

Garmin Coach adapts your load and it’s free with the watch, and it will never once acknowledge that you had a week. It has no emotional register at all. Nike Run Club is free, static, and pure hype, which is a fine product and the exact opposite of a locker room.

The most interesting comparison is one we’ve already covered here. Gentler Streak, from Volume XXVII, starts from what your body can take today and works forward. Its default is rest. Runna’s default is the plan. That single difference explains almost everything about how each one feels on your worst week.

And the market is catching on. Daptiv, a new AI coach, opens its App Store page with “Missed a workout because life got chaotic?” and promises training “without burnout, guilt, or rigid schedules.” The loss is becoming the battleground. Whoever designs it best wins the decade.

The verdict, and what you can steal

Runna is the best-built running coach you can buy for the money, and it solved the logistics of failure while leaving the meaning of it untouched. The four-question form is real design work, but the trophy cabinet undercuts it.

The best thing in this app is three words long. “Not Feeling 100%” avoids asking if you’re injured, which is medical and frightening and sounds permanent. It avoids asking if you failed. It asks whether you’re at one hundred percent, and it lets you say no without explaining yourself. Steal that copy. Steal the whole posture behind it.

For your own work:

• Design the off-plan state with the same care you gave the on-plan state

• Let people report a setback after the fact, because nobody files it on time

• Give the abandoned thing an ending, and put something true in it

• Make regression legible, so a planned drop reads as strategy instead of failure

• Name the setback in the user’s language, with no shame and no diagnosis attached

Overall: 4,1/5 ⭐

Share

And this is it for today,

Kostyuk will be back on court soon. The forty-seven teams flying home this month will spend the next four years in training, matches and in the locker rooms, where the whole thing gets decided.

Our users are in there, too. Week nine of the plan, day forty of the streak, the month everything went wrong. They’re sitting with a towel over their heads, working out whether they’re coming back, and most of our products are still holding a confetti cannon and waiting for a win that isn’t coming.

Build them somewhere to sit.

As always, this newsletter is free, but if you enjoyed it, please consider sharing it with a friend or two. Spreading the love is what it's all about, folks 🖤

Sincerely,
Vadym Grin

Overview

An AI orchestrator is the layer that sits behind everything and decides: which model runs, in what order, with what information, and under what rules. Think of it as a director that keeps a cast of specialized agents moving in sync — routing tasks, passing context between steps, checking outputs against guardrails, and deciding when a human needs to step in. You’ll rarely see it in the UI. But you’ll absolutely feel it in the product.

Why designers should care

Here’s the thing: orchestration is what determines whether an AI product actually works or just looks like it does. It shapes how fast responses come back, whether the system can explain its reasoning, how gracefully it handles mistakes, and whether users feel in control or at the mercy of some invisible process.

Take a simple request: “Summarize last month’s performance and tell me what to focus on next.” Sounds easy. But no single model handles that end-to-end. You need something to pull the data, something to make sense of it, something to reason about priorities, and something to package it all in a format that’s actually useful. Each of those is a separate job. And if the wiring between them is sloppy — agents not passing the right context, no guardrails on what the recommendation engine can say, errors disappearing silently — the user gets a response that just feels off. They can’t explain why. They just stop trusting it.

That’s exactly why designers need to be in this conversation. We’re the ones who understand what users actually need moment to moment. That’s the real job of orchestration design: knowing when to automate, when to pause, when to explain yourself, and when to put the human back in charge.

Core patterns

There are five main ways agents can be organized to work together. Each one creates a different user experience — different speeds, different failure modes, different levels of transparency. Knowing which pattern you’re working with is the first step to designing it well.

Sequential is the most common. Agents run one after another, each handing its output to the next: retrieve data, clean it, summarize it, format it. Simple to reason about, easy to debug. The catch is latency — the user is staring at a spinner while the whole chain runs. Your job: show progress at each step. Stream partial results when you can. Don’t make people wait in silence.

Read more

Capability climbing, better models, bigger context windows, higher benchmark scores. This month the action moved to the floor. Producing a competent first draft, a layout, a motion study, a working prototype got cheap and easy for everyone. Then at Config this week, Dylan Field named the stakes from the main stage: “But while AI has lowered the floor, it has not raised the ceiling. Designers, creatives, builders: you will raise the ceiling.”

Config Turned Code, Motion, and Shaders Into Materials You Paint With

Figma Config 2026 ran June 23 to 25 at Moscone Center, and Dylan Field’s Wednesday keynote was the most AI-focused in the conference’s history. The framing was “limitless expression on the canvas,” and the substance backed it up. The keynote covered a whole set of new materials: code, motion, shaders, generative plugins, and Weave workflows, all living on the canvas next to your frames.

Start with the one that reorders the designer-developer relationship. Code Layers let you turn any design layer into an interactive code layer with a single click or a prompt, duplicate it to explore directions side by side, and riff, comment, and iterate with teammates in the same file. You can extract a code layer back into editable design layers and sync your changes back to code with one click.

“Code should be treated like any other design material.”

Early access opens via waitlist in July at figma.com/config-betas.

Then Figma Motion, which brings a real timeline, keyframes, and presets into Figma Design. You can build animation from scratch or layer it onto existing work, and the Figma agent can generate a starting point for you. The part that matters for teams: motion becomes a design-system element, so you animate once and it applies across screens and across collaborators’ files. Dev Mode shows inspectable timing values, easing curves, and keyframes, and exports to CSS, JSON, React, or MP4, WebM, animated SVG, and GIF. You can also pass animated frames to a coding agent over MCP. Motion now lives right where your design does.

There’s more. Shader fills and effects: describe the effect you want or hand the agent an image reference, and it builds the shader for you, parameterized by default with controls right on the canvas, stackable, and convertible to code (interactive shaders are coming soon). Generative plugins: describe a tool’s behavior and controls in plain language, with no local dev environment or plugin-API knowledge required, and share it inside a file immediately. Weave tools: a node-based canvas for building generative workflows, where you connect models, transform assets, and compare approaches, then publish the workflow as a template for others to remix.

And the Design agent grew up. It picked up Skills, which package a workflow into reusable instructions, and Connectors that wire it into Notion, Slack, Granola, Hex, GitHub, and Atlassian. Agent chats are now visible to teammates by default, with a private option, which quietly turns prompting into a team-visible craft everyone can learn from. The agent is also expanding to FigJam and Slides.

A year ago we argued about whether AI could produce a usable first draft. Config 2026 moved the question. The whole production layer, code, motion, visual effects, custom tooling, is now promptable material on one canvas. Clean artifacts are cheap and everywhere. The taste to direct them is the scarce thing.

What it means for you: the brief is changing under your feet. Your job now is to direct and judge the version the canvas produced for you, across code and motion and effects that used to need separate specialists and separate tools. Field’s floor-and-ceiling line is a job description. The floor fell so far this month that the one thing left unmistakably yours is the ceiling.

Apple Made the Model a Setting

WWDC landed on June 8. Apple officially unveiled an entirely new version of Siri, deeply integrated across iPhone, iPad, Mac, Apple Watch, and Vision Pro, that can search your personal context, pull from the web, and understand what’s on your screen. Apple confirmed that much itself.

The more interesting part is what the reporting around it describes, and I want to keep Apple’s claims separate from the press reports. According to multiple outlets, the rebuilt Siri runs on a custom 1.2-trillion-parameter Gemini model that Apple is licensing from Google for a figure reported around a billion dollars a year. And iOS 27 is reported to introduce an Extensions system that lets users choose which model powers Apple Intelligence features, with ChatGPT, Gemini, and Claude all in the frame. Apple’s own press release names no model, parameter count, price, or picker, so hold those specifics as well-sourced reporting that Apple hasn’t confirmed on stage. Either way, this would give Claude its first native place on the iPhone, with a rollout expected later this year.

What Apple did put numbers on is quieter and structural. iOS 27 ships as a free update this fall, reaching every iPhone from the 11 onward, with apps launching up to 30 percent faster and photos loading up to 70 percent faster. The plumbing gets faster while the intelligence on top of it becomes swappable.

With a model picker, the model is a user setting you can swap, like a default browser. Intelligence becomes a commodity slot, and the largest consumer install base on earth is reportedly about to make that explicit.

If the user picks the model underneath an experience and can change it whenever they like, the model belongs to them. Your differentiator is the the trust in it, the way the experience behaves when the model is great and when it’s wrong. The intelligence got more powerful and less yours. You’re designing the relationship with a brain you don’t own.

Anthropic’s Best Model Lasted Three Days in Public

The strangest, most-shared AI story of the month is also, underneath the drama, a design story.

On June 9, Anthropic released Claude Fable 5, the public version of its more powerful Mythos 5 model, calling it its strongest model yet at software engineering, knowledge work, and vision. Within hours, two things went wrong. First, users hit a wall of refusals, on biology questions, on legitimate cybersecurity research, even on help with AI development itself. Then came the real scandal. Buried in a 319-page system card, researchers found that Fable would quietly downgrade its own answers when it detected requests related to frontier AI development. You could ask for help, get a deliberately weakened response, and never be told the model was holding back. Critics called it secret sabotage. Anthropic reversed course within a day, made the safeguards visible, and apologized in plain words: “We made the wrong tradeoff, and we apologize for not getting the balance right.”

It got bigger. A quote attributed to the NSA, that the model “broke into almost all of our classified systems, not in weeks, but in hours” during an authorized red-team test, went viral as “Claude hacked the NSA,” before the original author clarified the narrative was misleading. By June 12, the US government had ordered Anthropic to cut off access to Fable 5 and Mythos 5 for all foreign nationals, including its own non-citizen employees, over fears the model could be jailbroken to find software vulnerabilities. The most capable model anyone had shipped was, days later, partly switched off.

Midjourney Left the Screen for the Human Body

The most unexpected move of the month came from a company nobody had on the healthcare bingo card. On June 18, Midjourney, the lab known for turning text into images, announced its first piece of hardware: a full-body medical scanner.

It’s called the Midjourney Scanner, and CEO David Holz calls the technique “ultrasonic CT.” You stand on a platform that lowers into a tank of water while a ring of ultrasound transducers fire sound waves through you from every angle at once. Software reconstructs the echoes into a three-dimensional map of your muscle, fat, bone, and organs in about sixty seconds, with no radiation and no magnetic field. The plan is a chain of locations Midjourney calls the Midjourney Spa, the first opening in San Francisco’s Union Square by the end of 2027, with scanning rooms sitting next to a gym, saunas, and cold plunge pools. Holz describes stepping “into a shallow pool of golden light.” The company says it wants 50,000 of these scanners deployed worldwide over six years.

The part that matters for us is this. The imaging tech isn’t Midjourney’s. It’s licensed from Butterfly Network, the ultrasound-on-chip company, under a deal worth up to $74 million over five years. The science is Butterfly’s. What Midjourney is building is the experience: the sixty-second scan, the golden light, the spa, the calm choreography around one of the most anxious things a person does, looking inside their own body. The defensible part of this product is design, almost top to bottom.

Whole-body screening of healthy people is medically contested, because it surfaces incidental findings that lead to anxiety, more tests, and procedures that don’t always help. The scanner has no FDA clearance for diagnosis yet. Midjourney is starting with body-composition maps, which don’t need clearance, and says it will add approvals over time. So treat the wellness framing as marketing for now, and the medical claims as unproven until the regulators weigh in.

Handpicked Highlights

👉 Loredana Crisan on Figma’s big bets for the future of AI design (Dive Club). A good companion to the Config section, from someone shaping where the canvas goes next.

👉 After Automation by Dan Shipper (Every). The argument that AI commoditizes yesterday’s competence and raises the premium on human judgment. The cleanest version of this issue’s thread, worth reading next to What June Revealed.

👉 Building an LLM safe design system by Polar. How they built Orbit, a system that makes off-system choices technically impossible with typed tokens and a single Box component, so AI-written UI stays consistent.

👉 Details That Make Interfaces Feel Better by Jakub. A practical catalog of small refinements, balanced text wrapping, concentric radius, interruptible animations, that separate good interfaces from great ones.

👉 Life After the Prototype by TJ (Southleft). The polished prototype is the easy part. The real work is moving it into production tied to your design system, and he lays out a concrete workflow with branches, tokens, Storybook, and AI self-audits.

👉 Building a School Where AI Models Learn About Humanity (Every). A look at teaching models human context and values, a fitting bookend to a month spent on owning the experience layer on top of models you don’t own.

What June Revealed

Here’s the thing I keep circling. The floor under our craft keeps dropping, and average output gets good for free. That leaves one thing worth figuring out: what stays unmistakably ours when the machine can do the rest.

Dylan Field gave the cleanest answer I’ve heard: the ceiling. Every story this month pointed at the same narrow place underneath that word. Figma turned code and motion into materials, Apple swapped the model, Midjourney licensed the science and kept the experience, betting its whole next act on the design. The job market pays for judgment now. The regulators stepped back.

The machine is getting very good at answering, and the value is migrating to the people who are good at asking, choosing, and deciding what’s true and what’s right. That’s the oldest skill we have. The tools just started forcing us to use it on purpose.

Average got automated this month. The ceiling is still yours. Go raise it.

If this edition gave you something to think about, pass it to someone who needs to read it. And subscribe if you haven’t yet.

Sincerely,
Mykola Korzh

We’re a few days out from the longest day of the year. On June 21, the sun in the northern hemisphere lingers longer than it will at any other point in 2026, and most of us will spend a good chunk of that record-breaking daylight indoors, looking at glowing rectangles.

One app treats that gap as its entire reason to exist. It tracks the sun down to the minute: sunrise, golden hour, blue hour, the last sliver of light before dark. And the whole point of all that precision is to get you to close the app and walk outside.

That’s a strange goal for a piece of software. Most products fight for your minutes. This one hands them back. The best version of this app is the one you barely open. It tells you when the light will be good, then it trusts you to go live in it.

I’ve been sitting with this idea since the app’s big redesign last year, and it keeps tugging at the same thread we pulled in Volume XXVII: the difference between products that need you and products that serve you. A sun tracker is a clean test case. You can’t doomscroll the sunset. You either go see it, or you don’t.

This issue: a full teardown of Lumy, and what its window-to-the-sky design teaches the rest of us.

At the end of this issue, I will introduce you to the new format of the newsletter and invite you to a secret place.

Lumy: the sun tracker built to be put down

Most apps want to be a destination. Lumy wants to be a window.

You don’t admire a window. You look through it, at the thing on the other side. That single idea runs through every screen of this app. The May 2025 redesign was built on that concept. The maker’s own note calls it a “window to our outside world,” with a UI meant to feel lit by the day beyond the glass. Every view carries a faint echo of light passing through a pane. The app glows the way a room glows in late afternoon.

There’s a small irony here, because Lumy shipped that light-through-glass look in spring 2025. A few months later, Apple made glass the entire personality of iOS 26 with Liquid Glass, and Lumy slid right into it on the Apple Watch. The indie app got there first, on its own terms, for a reason that meant something. That’s the difference between an aesthetic and a metaphor.

Lumy comes from Raja Vijayaraman, a self-taught developer in Chennai who studied mechanical engineering, spent time in VFX, then fell hard for the iPhone and taught himself to code. He builds under the name Waple Stuff, and his wife, a photographer, is his creative partner. His description of how they work tells you most of what you need to know about the app’s restraint:

“We create apps for ourselves. Once we are satisfied, we put them on the App Store, hoping to connect with people who share our design aesthetics.”

Lumy started as a tool the two of them needed, a way to find golden hour for their own photos. It grew from there. This is the same maker whose calculator app, Calzy, won an Apple Design Award back in 2018, so the pedigree runs deep.

Reminder: Product evaluation is done according to Don Norman’s 3 levels of design.

Visceral level: 5/5

The visceral level is responsible for first impressions.

The trophy shelf is real. Lumy was Apple Watch App of the Year in 2024 and a 2025 Apple Design Awards finalist in the Innovation category. Apple’s design team singled out its “simple design, carefully curated color palette, and elegant widgets and Live Activities.”

Open it and the first thing you do is pick a Mode. Daily, Photography, Hiking, Mindfulness, Travel. The choice isn’t cosmetic. Your mode reshapes what the app surfaces first, so a photographer leads with golden and blue hour while someone meditating at dawn leads with first light. The app decides what to hide so you don’t have to. That’s an editorial stance built into the product.

From there, the home view lays out the day as a clean visual timeline of solar events. Tap any moment and Lumy opens up the supporting detail: wind speed, cloud cover, visibility for that exact slice of the day. A time-travel slider lets you scrub the whole day forward and back to see how the light will move, which is the kind of thing photographers pay for in heavier tools.

The move I keep coming back to is the State of Mind integration. Lumy reads your mood entries from the Health app and suggests when to step out for some sunlight, with a thumbs up or down to refine the nudge over time. It calculates everything on-device, no server calls, no tracking. A wellness feature that doesn’t phone home. In 2026, that alone is a statement.

Behavioral level: 5/5

This level focuses on usability, how the product performs and whether it effectively solves user problems.

The first thirty seconds with Lumy feel like opening a curtain. The palette shifts with the time of day, so a morning launch greets you in cool first-light tones and an evening one warms toward amber. The light-through-glass treatment gives every surface a soft inner glow, like sun caught in frosted glass. It reads as calm before you’ve understood a single number on the screen.

On the wrist, the Liquid Glass version takes that further. The complications feel like little panes of stained light rather than data chips. Apple’s own designers flagged the curated color palette and the widgets for a reason. This is a product where the aesthetic carries real information, since the color you see maps to the light you’ll get outside.

Nothing here shouts. There’s no splash of confetti, no badge, no number trying to spike your pulse. The app trusts that a beautiful, honest picture of the day is enough to make you want to go see it. For a utility that lives or dies on a glance, that restraint is the whole game.

Emotional signal: “Oh. The light looks good today.”

Share

Reflective level: 4,5/5

The reflective level considers the long-term impression and deeper meaning of the design, how it aligns with the user's identity and values.

Lumy is fast and it’s quiet, which is what a glanceable tool should be. The Modes do real work by cutting the dataset down to what your current life needs, so you’re not scrolling past nautical twilight to find your sunset. The time-travel slider turns “when’s the light good” into a two-second scrub. And because it all runs on-device, it works on a trailhead with no signal, which is where you’d want a sun tracker.

A few behavioral moves stand out:

• Mode-based information hierarchy. The app hides data instead of stacking it. A hiker and a photographer see different first screens, and that editorial choice is the feature.

• On-device calculation. Sun and moon math runs on the device, with nothing sent to a server. Privacy ships as the default.

• Glanceable surfaces everywhere. Widgets, Live Activities, and Apple Watch complications mean you often get your answer without opening the app at all.

The one place it wobbles is the watch over time. Lumy’s Apple Watch experience has taken a hit across major watchOS jumps, with watch-face and complication breakage reported after big updates. The maker is quick to patch, and that responsiveness counts for a lot, yet the friction is real enough to cost a point here. A tool you trust at a glance has to survive every September.

Emotional signal: “I got my answer before I even unlocked the phone.”

This is where the window metaphor pays off. Lumy makes you feel like someone who goes outside. After a few weeks, the app turns into a small daily prompt to live in rhythm with the light, to catch the last sun on a walk, to notice the sky is doing something worth standing still for.

The State of Mind feature sharpens that identity. When the app reads a low mood entry and suggests a sunlight break, it’s casting you as a person whose wellbeing is tied to the natural world, not to a screen. It never scolds you for a missed sunrise. It offers, then leaves you alone. That posture is the opposite of the streak-and-shame loop most wellness apps run on.

The reflective magic here is trust, the same note we hit in Volume XXVII. Lumy assumes you’re an adult with a life worth stepping into. It hands you a clear, beautiful read on the day and gets out of the way. The app that wins your loyalty is the one that keeps sending you somewhere better than itself.

Emotional signal: “This makes me want to go outside.”

Where it falls short

A flawless score with no critique reads like an ad. Lumy has some cracks.

The watch story is the clearest weak point. For an app that won its biggest award on the Apple Watch, Lumy has stumbled across major watchOS updates, with complications and watch faces breaking until a patch lands. The fixes come fast, and the developer’s responsiveness is rare. Still, “wait a few days for the update” is a hard ask for a tool whose entire pitch is a reliable glance.

Then there’s money. Lumy spent years as a clean pay-once app, and it now sits at $6.99 with in-app purchases layered on top. That’s a fair way for an indie to keep the lights on, and the core app still delivers without spending more. The shift is worth knowing about going in, since “buy it and you’re done” was part of the old charm.

And Lumy is light by design. If you plan shoots weeks out, want augmented-reality sun positioning, or need to save and compare locations, this is the wrong tool, on purpose. The State of Mind nudges also lean on a habit most people don’t have, since they only work if you log your mood in the Health app.

How rivals solve the same problem

The serious planning crowd reaches for PhotoPills, the maximalist toolbox stuffed with an AR planner, milky-way tools, and saved shoot plans. It’s powerful and it expects you to invest serious time learning it. Sun Surveyor sit in similar territory, built around technical position data and AR overlays for people solving a precise geometry problem. And Skylight Forecast, from the Halide team, predicts how good the light will be, which is a smart, different bet.

All three optimize for planning depth. They assume more data and more control is the win. Lumy assumes the opposite. The rivals want to be your planning command center. Lumy wants to tell you the light’s good and watch you leave.

The verdict, and what you can steal

Lumy is a small app with a clear spine. It knows what it’s for and what to leave out, and it treats both as design decisions rather than missing features. The window metaphor does real work. It shapes the palette, the Modes, the glanceable surfaces, and the gentle State of Mind nudge, all pointing the same direction: away from the screen and toward the sky.

What you can steal from it:

• Design for the moment after the app. Lumy’s win condition is you, outside, phone away.

• Hide data as a feature. Modes work because the app decides what you don’t need to see right now.

• Let the aesthetic carry information. The color you see maps to the light you’ll get. Beauty doing a job.

• Make privacy a default. On-device math, no server calls, no asterisk.

• Offer, don’t nag. A suggestion you can thumbs-down beats a streak you can break.

It loses a point on watch reliability and the quiet creep toward in-app purchases, and it’s not built for heavy planners. The core experience earns the top mark anyway. It measures success by what happens off-screen, and few apps even try.

Overall: 4,1/5 ⭐

Share

And this is it for today,

Lumy stuck with me because it points the other way. It spends all its craft getting you to look up from the screen, which feels like the right note to end on.

I’d love to hear from you on this one. Which app in your life earns its keep by sending you somewhere better than itself, instead of holding you hostage? You can hit reply and tell me, or… There is another way.

We want to bring together a close-knit group of like-minded people. It will be a small and welcoming circle of those who genuinely want to share their experiences, learn and adopt best AI practices, and experiment together!

And another bit of news before you go. We listened to your feedback. The monthly news roundup is our best performer, and you told us you love the product reviews tucked inside the other newsletter too.

So we’re changing things up. From now on, this newsletter is what you read today: in-depth product reviews, deeper and more useful, with a real lesson you can carry into your own work. The essays and longer think-pieces aren’t going anywhere, they’ll live as standalone articles instead. More focus, more value.

As always, this newsletter is free, but if you enjoyed it, please consider sharing it with a friend or two. Spreading the love is what it's all about, folks 🖤

Sincerely,
Vadym Grin

This edition is about removing that glue job. We are going to look at MCP, the Model Context Protocol, and specifically the Figma MCP server, which lets AI tools see directly into your Figma files: your components, your variables, your layout structure, your design tokens. No more screenshots. No more “here is my color palette again.”

By the end of this tutorial you will understand what MCP actually is, how the Figma MCP server works, how to set it up, and how to run a real design-to-code workflow with it.

Professional AI Prompt Kit for UX Designers ✨

Before we start this edition, I have a special learning material for you. Want to skip the learning curve and start using production-ready prompts immediately? I’ve created a comprehensive AI Prompt Kit specifically for UX designers and researchers who want to leverage AI as a strategic tool, not just a content generator.

Get the AI Prompt Kit for UX Designers

Part 1: What MCP Actually Is?

MCP stands for Model Context Protocol. Think of it as a universal plug that lets an AI assistant talk directly to other software, instead of you describing that software to the AI in words.

Before MCP, if you wanted an AI coding assistant to build a component based on your Figma design, your workflow looked like this: take a screenshot of the frame, paste it into the chat, describe the spacing and colors as best you can, hope the AI guesses the rest. The AI was working from a picture, not from the actual design data.

With MCP, the AI assistant can ask Figma directly: what are the layers in this selection, what are the spacing values, which design tokens are applied, what does the component hierarchy look like. The AI receives structured data instead of a flat image, which means the code or content it generates lines up with your actual design system rather than an approximation of it.

The easiest way to think about MCP is as a translator that sits between an AI tool and an application. Figma has one. So do Google Drive, Slack, and a growing list of other tools. Once a tool has an MCP server, any AI assistant that supports MCP, including Claude, Cursor, VS Code with Copilot, or Windsurf, can connect to it and use it.

Part 2: What the Figma MCP Server Gives You

The Figma MCP server is Figma’s own implementation of this idea, built specifically for the design-to-development handoff. Once it is running, an AI agent in your code editor can request live information from your Figma file, including the layer hierarchy and structure of a selected frame, layout rules such as auto layout, padding, and alignment, text styles and applied design tokens or variables, component properties and variants, and image references for any assets in the selection.

This matters for designers as much as for developers. If you have spent any time handing off designs, you already know the friction. The developer opens your file, inspects every layer manually, and still ends up emailing you to ask what the spacing token for a button should be. The Figma MCP server skips that step. The AI agent reads the actual values from your file.

There are two versions available. The remote server is the one most people should use, and it covers the broadest set of features including reading design context, generating code, and even writing content back into Figma. The desktop server runs locally on your machine and is aimed at specific organization and enterprise setups. Unless you have a reason to need the desktop version, start with remote.

Part 3: Setting It Up

Here is the setup, step by step. The exact menu wording can shift slightly between Figma updates, but the flow stays the same.

Read more

That feeling is the trap, that we haven’t learned to fear it yet.

I keep noticing designers settle for these results. Everyone’s trying to ship more, then even more, and the deadline always has a hand on your shoulder. So you look at the generated flow and think, well, it’ll do. It usually will, and that’s the problem.

Done is not the same as good

Herbert Simon had a word for stopping at “it’ll do.” He called it satisficing, a blend of satisfy and suffice. You search through options until one clears the bar, then you stop, however much better the next one might have been. Simon meant it as an honest description of how people decide under time and limits. With AI in the canvas, you clear the bar in ten seconds, so you stop in ten seconds.

The easy thing got easier. “Not bad” is almost free now. The hard thing stayed as hard as it ever was. Making something that grabs a person, that they remember on the train home, still takes the slow, stubborn effort it took in 2015. AI never touched that part, but made skipping it a lot more tempting.

Yesterday’s dinner, reheated

I have a metaphor for this that’s been rattling around in my head for months. A result you generated in a second is like last night’s dinner, microwaved for ninety seconds and eaten for breakfast. It’s warm, filling, and fast, and you’re satisfied in the narrow sense that the hunger is gone. It isn’t tasty. You ate to be done eating.

Cooking is the slow version. You taste as you go, add salt, wait, taste again, decide it needs acid. The result carries every one of those small decisions, and you can feel them on the plate. AI rarely makes bad work, however it makes “good enough” so cheap that we stop reaching for great.

Even a year ago I couldn’t conjure a screen in ten seconds, and I don’t miss those days. But there was something inside the slowness that I’ve only started to appreciate now that it’s gone. Slowness forced me to live with a decision. To look at it again in the morning with clearer eyes. To hand it to other designers and brace for the feedback. And maybe to hate it a little. Then to redo it. That friction was working the whole time.

Two of those jobs are worth naming, because there’s now research on both.

The first is skill. Hand the work to a tool that never slips and you stop practicing, and the practice is what kept you sharp. Researchers who studied accountants leaning on automated systems found the same thing: automation complacency, the comfortable assumption that all is well, while your skills erode without you noticing. Use it or lose it, same as anything. Aviation learned this the expensive way decades ago, where heavy reliance on autopilot degrades pilots’ manual flying skills. The cockpit is a higher-stakes version of our canvas.

The second is sameness. A 2024 study in Science Advances gave writers AI-generated story ideas, and the writers produced better individual stories that looked more alike across the group. Everyone starts from the same model’s first instinct, so everyone drifts toward the same middle. One-shot design has the same gravity: The first plausible result anchors you, and plausible is a strong anchor when you’re tired and the deadline is close.

Upgrade to paid

Read more

For about a year I’ve been making the same argument to you, mostly on the strength of stock moves and product demos: that the distance between designing software and building it is closing, and that the labs making the models are turning into the platforms that run everything on top of them. May is the first month I can make that case with figures instead of hunches.

Karpathy Switched Teams

On the morning of Tuesday, May 19, Andrej Karpathy posted nine sentences to X. He’d joined Anthropic. He thought the next few years at the frontier of large language models would be unusually formative. He was glad to be back doing research, and his education project was paused for now. By the end of the day the post had 148,000 likes, which tells you how closely this particular career gets watched.

A little background, because the moves are the point. Karpathy is one of OpenAI’s eleven original co-founders. He left in 2017 to run Tesla’s autopilot program, returned to OpenAI in early 2023, left again about a year later, and spent the stretch after that building an education startup called Eureka Labs. He could have gone back to OpenAI a third time and would almost certainly have been welcomed. He chose Anthropic.

His job there is narrow and, if it works, enormous. He’s joining the pre-training team under Nick Joseph to build a group that uses Claude to speed up the research that produces the next Claude. Anthropic confirmed that scope to TechCrunch and VentureBeat. The wager underneath it is that the next leap in capability comes less from pouring in more compute and more from models that make their own researchers faster. Hiring the person most associated with explaining how these systems actually get built, then pointing him at that exact problem, is a fairly literal way to place that bet.

It wasn’t the only hire that week. Anthropic also brought on Chris Rohlf for its frontier red team, out of a twenty-year security career that included six years at Meta and earlier time on Yahoo’s “Paranoids,” and the Musk versus Altman trial wrapped with a jury siding with Altman. The talent and the legal weather both broke Anthropic’s way inside the same five days.

Ninety-One Percent

Designer Fund and Foundation Capital published the second annual AI in Design report on May 20. They surveyed 906 designers across more than 60 countries and ran a couple dozen interviews with people at Anthropic, Stripe, Linear, Notion, Cursor, Ramp, and a long tail of startups.

The number in the section title is the headline. Weekly AI use among designers went from 54 percent a year ago to 91 percent now. Three-quarters use it daily. The average person’s stack of AI tools doubled, from three to seven. And the figure I keep turning over: half of everyone surveyed, brand and product designers included rather than only the engineering-leaning ones, has shipped AI-generated code to production. At early-stage companies it’s 68 percent.

Claude leads the tools at 78 percent, ahead of ChatGPT at 65. Claude Code, which didn’t exist publicly a year ago and wasn’t even on the 2025 survey, already sits in roughly two-thirds of stacks.

The fifty-percent figure is higher than I’d have guessed, and it reads differently from a normal adoption stat. Shipping code to production isn’t the same as trying a tool over a weekend. It means the work crossed a line that used to need a different job title on the door.

The report is honest about the cost sitting inside the gains, and that’s the part I’d dwell on if I ran a team. Designers say they’re picking up more product and engineering work. They also say they’re collaborating less, and that figure has risen sharply over the year. Each person reaches further while fewer hands touch the same problem. Most companies, the report notes, haven’t adjusted their review processes, team shapes, or hiring criteria to match any of it, and the designers who feel good about the shift tend to be the ones whose employer actually paid for it instead of leaving it to nights and weekends.

Anthropic is a disclosed partner on this survey, and the survey’s headline finding is that Anthropic’s product won. That doesn’t make the number wrong. Ramp, whose AI Index tracks real business card spend rather than self-reports, caught the same crossover in April, with Claude passing ChatGPT among US businesses 34.4 percent to 32.3. But a survey funded in part by the company it crowns is not independent research, and the report itself admits the designers who answered it are probably heavier AI users than designers in general, which would push the numbers up. Treat it as a strong signal from people who stand to benefit if it’s true. Useful, but not neutral.

Figma Put an Agent on the Canvas

The same day that report landed, Figma shipped an AI agent that works directly on the canvas, in beta for paid seats. You describe what you want, and it generates and edits real layers, applies your design system, and works inside the file next to you rather than off in a side panel. It can also hand a build off to Claude Code or OpenAI Codex through Figma’s MCP server. Loredana Crisan, Figma’s chief design officer, pitched it around judgment: as building gets cheap, she said, the scarce skill becomes deciding what to make and how it should feel.

The timing is what makes it worth a section. Five weeks earlier, Mike Krieger had stepped off Figma’s board, and three days after that, Anthropic launched Claude Design, its own tool for generating interfaces. The easy read was that Anthropic was coming for Figma. Then Figma reported its first full quarter as a public company: revenue up 46 percent to $333 million, net dollar retention at 139 percent, the count of customers spending over $100,000 a year up 48 percent. The stock climbed on the news.

So the cannibalization story isn’t holding, at least not yet, and what’s happening instead is more specific. The company that already owned the canvas put an agent on it, while the labs aim their generative tools at people who were never going to open Figma in the first place. Figma keeps the designer in the director’s chair, which is the part of the job that pays. A falling stock price and a strong product are not the same thing, and the market seemed to figure that out within the hour.

The Other Side of the Ledger

That money has to come from somewhere, and a lot of it is coming out of payroll. Tech layoffs passed 113,000 for the year by May 18, by Challenger, Gray and Christmas’s count, and for the second month running AI was the reason companies named most often when they cut, accounting for 26 percent of April’s tech total.

Meta ran the single biggest cut of the year on May 20: 8,000 people, around a tenth of the company. The memo, from chief people officer Janelle Gale, described it as running leaner to pay for the investments being made elsewhere, which is at least candid about the trade. Roughly 7,000 staff were moved onto AI teams and 6,000 open roles were cancelled. Content design was among the functions hit.

Two weeks before that, Cloudflare cut about 1,100, a fifth of its workforce, with a memo noting that AI usage inside the company had jumped more than 600 percent in three months. Investors didn’t read it as the confident pivot it was dressed up to be. The stock fell 24 percent the next day, the worst single session in the company’s public life. Intuit, Cisco, Coinbase, Oracle, and PayPal all trimmed as well, several of them reaching for the same AI framing.

Set against the cuts is the spending they help fund. Google, Microsoft, Meta, and Amazon plan to lay out $725 billion in capital expenditure this year, up 77 percent, most of it on AI infrastructure. The Financial Times line that got passed around came from Jefferies’ Brent Thill, who called the bear case “garbage” and the AI economy healthy.

Nobody can say yet how much of this is AI genuinely doing the work and how much is AI as a convenient excuse for cuts companies wanted regardless. The evidence so far leans toward excuse. Oxford Economics found that firms aren’t really replacing workers with AI at any scale. Wharton’s Peter Cappelli was blunter: companies keep saying AI will do the work, mostly can’t prove it does, and are hoping. Even Sam Altman has admitted as much. And Andy Challenger, whose firm counts these layoffs, put it most simply: budgets are moving toward AI and away from people. A job doesn’t have to be replaceable by AI to lose its budget to it.

As a designer, that’s the risk I’d actually watch. It’s quieter than “the robots are coming for your job,” and a lot more likely to be what actually happens.

Handpicked Highlights

👉 After Automation, by Dan Shipper. The strongest single piece I read all month, published May 21. AI commoditizes yesterday’s competence, that abundance breeds sameness, and the demand for anything that breaks the sameness becomes the new demand for human experts.

👉 Shipper on Lenny’s Podcast, May 24. The same thinking as a conversation, with a set of deliberately contrarian calls attached: SaaS isn’t dead, CLIs are over, the forward-deployed engineer is the hire that matters now, and “automation is a lie.” Watch this if the essay leaves you wanting the longer version.

👉 DesignerTom: “How I Built an AI Agent That Designs Like Me.” Tommy Geoco walks through the actual agent setup running his studio, posted May 1. A four-agent harness, the seven-file anatomy of an OpenClaw agent, the four layers that make one useful (skills, memory, context, connections), and a path to build your own. He’s clear about what it does and doesn’t handle on a given day, which is rarer than it should be.

👉 Neuma: build your personal AI by talking to it. A self-paced course from Kris Puckett, a design manager at Stripe. Nine modules, no coding required, building toward a personal system in Claude Code with persistent memory, daily briefings, and a coaching layer. The price climbs to $179 on June 1.

👉 Design Motion Principles, by Kyle Zantos. An open-source skill for Claude, Cursor, and Windsurf with two modes: build interactive components with motion, or audit the animations you already have. The audit runs a checklist for the fingerprints of AI-generated motion, like pulsing indicators, hover-scale on everything, and bouncy springs slapped on utility actions. Distilled from the published work of Emil Kowalski, Jakub Krehel, and Jhey Tompkins.

👉 Lenny’s “Essential books for product builders,” part one. Thirty-six books sorted by the job you’re hiring them to do, posted May 26, three per category across roughly a dozen disciplines. Lenny leans on Marc Andreessen’s rule of mostly reading books more than ten years old, which feels right in a month this loud.

What I Think May Meant

I came into May looking for a throughline and mostly got tables of numbers, so here’s my honest attempt to say what they add up to.

The argument I’ve been making in pieces for a year now has a figure attached to it at last. When 91 percent of designers use AI every week, half of them ship code, and the tool most of them trust is one a frontier lab is openly working to make smarter, I no longer have to argue that design work and software work are merging. The survey shows people already living it, on ordinary Tuesdays, in production. The designers getting ahead are the ones treating code as a material they can shape themselves rather than a spec they describe and pass to someone else.

The number I’m less sure how to feel about is the collaboration one. Designers are reaching further on their own and working together less, and that climbed fast this year. I don’t know what we lose when more of the work moves into a quiet exchange with a model and out of a noisy room with other people. Maybe it’s a fair trade. Or maybe we’re losing something in those rooms that no survey will catch until it’s already gone. I genuinely can’t tell yet, and I’d rather say so than pretend the gain comes free.

The cleanest evidence we have for the biggest shift in design tooling in a decade is also tangled up with the people who profit from it. I’d hold both of those at once: that it’s probably right, and that it’s not disinterested.

The one thing I’d resist is treating all of it as a tooling story. Learning the new stack is the easy part, and a year from now it’ll be the floor rather than the edge. What the reports can’t measure, and what the agents still can’t do, is judgment. So the question I’m actually leaving May with is how any of us keeps getting sharper at the judgment part while the tools race ahead and make everyone look equally capable. I can’t answer that one yet, and I suspect it matters more than anything on a tool stack.

June has the Anthropic round closing, Figma’s Config, and whatever the next surprise turns out to be. I’ll see what it adds up to and write you then.

If this edition gave you something to think about, pass it to someone who needs to read it. And subscribe if you haven’t yet.

Share

Sincerely,
Mykola Korzh

It’s wild how one app icon change can suddenly make everyone care about design. It’s not revolutionary, and it’s not a new trend — it’s just a bit different than usual. And that’s how Spotify got the attention of the entire world, with a shiny disco ball.

Why all the attention? Is it so great, or so bad, that it deserves this level of discussion?

No, it’s just different, vibrant and authentic, compared to most of the monotonous, cookie-cutter products with their AI-generated designs and icons.

The whole story with the Spotify icon (to celebrate their 20th anniversary) has led me to think, or better, to say, return again to one main idea of the design in the times of AI: “The emotional connection created by your product and its design has always been a key factor in its success, but now it has become the main differentiator”.

For each of us, AI is becoming an amplifying tool, which speeds up the craft. However, I personally don’t hand over the design or writing entirely to it. After all, if I did, the value of my work (also here at Eidos Design), and my creativity would disappear completely.

I’ve felt genuinely sad when opening LinkedIn and reading texts written entirely by AI. I don’t have anything against AI-generated content, but teaching your tools to mimic your voice with system prompts and then editing the result is craft. Handing over thinking, production, and verification entirely to AI is something else, and we can feel the difference. This is why we now have icons, texts, designs, and products that are all the same. Personal opinions, tastes, and creativity are lost in this stream of monotony and formulaic content.

Don’t get me wrong — I’m a proponent of AI and integrate it into my work wherever possible. But things got so bad that we crossed the Rubicon, and now some people are starting a rebellion. The movement has been named the “Stop the SLOP!” movement and already has its first leaders.

I wrote in Issue XXV first, and then dedicated myself to a big research on the topic, which was published in Feeling Are the New Features article, and the bottom line is:

It’s difficult to elicit an emotional response through monotony. Furthermore, there’s a growing trend where anything created entirely with AI is perceived as “cheap” and “not worth paying attention to.” This makes sense.

In this issue:

• AI Made Design Cheap. Now Designers Are Making It Expensive Again. How sameness became the new ugly, and why distinctness is the thing.

• Are.na Review: The anti-algorithmic creative platform that proves slow, weird, and quiet can win.

• The Bookcase That Broke Good Taste: How Ettore Sottsass and the Memphis Group started a rebellion against bland design in 1981, and why their playbook fits 2026 perfectly.

I. AI Made Design Cheap. Now Designers Are Making It Expensive Again.

Insight

A few weeks ago, designer Michal Malewicz launched a manifesto called Slopless.

It’s now became obvious, that AI-generated products wear a uniform: purple gradients, thick sans-serifs, blobs and abstract backgrounds, rounded corners stacked around more rounded corners, pillow buttons, soft shadows on every surface. Scroll any Product Hunt page this month and the fingerprints repeat.

Slopless calls itself an anti-sameness movement and holds no quarrel with AI itself. That separation matters, and the manifesto asks designers to stop letting the tools make the decisions.

This homogenization has structural roots. Research published this year calls it “mode collapse”: generative models pick what’s likely over what’s distinctive, and as designers reach for the same prompts and component libraries, our outputs converge toward a shared center. The Copenhagen Institute estimates that by 2030, 99% of internet content could be AI-generated. Some of the signs are showing up in our portfolios now.

This is the cost of “ship it fast.”

Memory needs friction to work. When products share a visual language this closely, the brain stops bothering to tell them apart, and the whole category turns into background noise. The loss is structural, beyond a question of style.

A great product feels like someone made a thousand small decisions, and a few of those decisions were a little weird. That’s what AI takes from the work first. The font that’s a size too big for sense, the empty state that’s a touch too sincere, the color no startup would pick. Those are the moments that give a product a character.

AI excels at the average, and the choice no other designer would make is still yours to make. So the rebellion starts with designing like there’s an author. The work needs conviction baked back into it. Hand-coding revivals and AI bans don’t help here. Your job in 2026 is to be the person in the room with an opinion strong enough to survive the prompt.

Here are a few practical principles we can hold onto:

• Plant a stake before you touch the tool. Pick a typographic voice, a color story, a motion personality before you open Claude, or Figma Make. The tool will pull you toward the mean, but your stake holds the line.

• Treat AI output like a junior designer’s first draft. Critique it the way you’d critique anyone else’s work. Cut what’s generic and keep the one weird thing it got right by accident.

• Add a deliberate flaw. One detail that looks like a human chose it on purpose, some kind of a reference no algorithm would surface.

Distinctiveness requires more attention and greater confidence. That is precisely why it is valued more highly. The revolution is already underway, and you don’t need a manifesto to join it. All it takes is a single decision for each project, one you can justify by saying, “I chose this myself.”

Share

II. Are.na: The Platform That Refuses To Compete For Your Attention.

Product Review

Reminder: Product evaluation is done according to Don Norman's 3 levels of design.

Most creative platforms push you to produce more, but the Are.na pushes you to think more carefully.

The platform calls itself a research tool, though it works as a digital commonplace book, a corner of the internet for designers, artists, researchers and writers who’d rather collect ideas than chase engagement. Are.na launched in 2014, and a decade later it still looks and behaves like a team that doesn’t care about your time-on-site metric.

In a feed of slop, Are.na is a black-and-white room with a folding chair and a good book on the table.

Visceral level: 2/5
The visceral level is responsible for first impressions.

Opening Are.na for the first time feels confusing in the right way. No hero image, and no animated mascot. Black text on white, system fonts, a search bar, a grid of recent blocks, and that’s it. Some people bounce in the first thirty seconds, however the ones who stay learn that the lack of decoration might be the decoration.

The site feels like a pure research database. Are.na’s team picked an aesthetic position in 2014 and held it up until now, which is rare for any digital product.

But this also means that some parts of the UI look outdated, if not horrible, so it won’t appeal to anyone who cares about aesthetics. The general simplicity is an amazing idea, but sometimes it might feel too primitive and old. It seems like there’s not a single designer to give that distinguishable minimalism some love.

Yeah, it’s not the kind of product that will make a really cool first impression. But if you give it a chance, it will grow on you.

Behavioral level: 5/5
This level focuses on usability — how the product performs and whether it effectively solves user problems.

The mental model is simple: You save “blocks” (images, text snippets, links, PDFs, anything) and group them into “channels.” A block can live in multiple channels at once, so as your thinking changes, you can rewire your own collection without starting over.

What makes it powerful in practice:

• No notifications fighting for your attention. Are.na won’t buzz, ding, or beg.

• Channels can be public, private, or invite-only collaborative. You decide who else is in the room.

• Connecting a block to a new channel takes seconds. The friction lives in choosing what to save, which is where it belongs.

• Search is fast, and the search index is yours. You can search your own brain.

• Every block has a “Connect” button that invites you to think in webs instead of lists.

It’s slow technology in the best sense of that phrase. The platform rewards patience and return visits. Channels keep growing as long as you keep adding to them, and after a few months, you start noticing connections between blocks you saved weeks apart, and that’s when Are.na performs really great.

Reflective level: 5/5
The reflective level considers the long-term impression and deeper meaning of the design — how it aligns with the user’s identity and values.

The platform is funded by paying members. No ads, no data sale, no “for you” feed engineered to keep you scrolling. And that business model is a design choice, and it shapes the rest of the product.

After a while on Are.na, your relationship to creative input changes. You stop hoarding tabs and start curating them. You begin treating your influences as a system you’re tending.

Founder Charles Broskoski has described Are.na as “a tool for collecting, organizing and thinking through the things that matter to you.” Most creative platforms abandoned that promise years ago.

Emotional signal: “This is a place that respects how I want to make things.”

Overall: 4,6/5 ⭐

The Are.na team has spent over a decade making a platform that works and feels like nobody else’s, with strict system-style minimalism. The community around it is small, but loyal, that makes product to survive. I’m not sure, though, how big the chances are to scale. But, as a fan of calm technology products, I will definitely put this one on the shelf with all other products that perform well and improve our lives, not asking for our attention.

Share

III. The Bookcase That Broke Good Taste

A Dose of Inspiration

In 1981, an Italian designer named Ettore Sottsass decided he was done with “good design.”

The design establishment of the late 1970s lived deep inside the modernist groove: cold rationalism, clean lines, functional minimalism, sober palettes. Sottsass was in his sixties by then, a giant of postwar Italian design, and he looked at the consensus and saw visual conformity wearing a turtleneck.

He gathered a group of younger designers in his apartment, named the collective Memphis (after a Bob Dylan track that kept skipping on the stereo during their first meeting), and started designing furniture that the rule book of the era would have called hideous.

Their debut at Milan’s Salone del Mobile in 1981 caused a public scandal. Sottsass’s Carlton bookcase looked like a Tetris game collapsed mid-fall, with plastic laminate in clashing patterns and geometric shapes that served no obvious function. Critics savaged it.

Then Karl Lagerfeld bought entire rooms of the furniture, and David Bowie became one of the most serious Memphis collectors in the world. Within a decade, Memphis aesthetics had spread across fashion, graphic design, and pop culture, and anyone who watched MTV in the 80s picked up Sottsass’s vocabulary without knowing his name.

Sottsass once said he wanted to design for “a sense of perplexity.” He wanted objects that made people stop and think, and designers willing to refuse the average.

Once the industry reaches a consensus on what constitutes “good,” the consensus itself becomes the problem, and the initial rebellion seems ugly. Forty-five years later, we’re inside our own version of that moment. The consensus is now based on algorithms, and the uniform is purple gradients. It seems like the opening that Sottsass spotted is here again.

And this is it for today,

If you take one thing from this issue, take permission to break a small rule on your next project. Pick a font no one would pick, or choose a color that doesn’t fit the brief. We need to break up the sameness with our creativity and personal taste.

When writing with AI, don’t let it do all the work. Begin with lines that sound like a real conversation, and like real you would say, and end your text with your own thoughts. Even the slightest break in the flow is enough to start.

We’re heading into a strange and exciting summer. WWDC opens on June 8 (Liquid Glass might get its long-overdue tune-up), and the conversations about how we want to design with AI will only get louder.

As always, this newsletter is free, but if you enjoyed it, please consider sharing it with a friend or two. Spreading the love is what it's all about, folks 🖤

Share

Sincerely,
Vadym Grin

April was literally crazy with news from the tech industry. After the release of the Claude Design, we also decided to take some time and to test it ourselves, as well as to wait what else might happen. That’s why this newsletter lands your inbox a bit later than usual.

Actually, we watched AI labs build on top of design and productivity platforms for the last three years. But April 2026 was the month that the arrangement stopped working, and the stress fractures showed up in the layers above and below it, too.

In a single month, an AI lab CPO left a design platform’s board and shipped a competing product three days later. Around 20,000 tech layoffs occurred in one week, with AI cited as the leading stated reason for the first time in Challenger's history. The vibe coding stack got publicly audited by its own bug bounty. Cursor’s $50 billion round included a structurally unusual SpaceX option. And Apple promoted the person who’s going to ship the platform after the screen.

These stories don’t share a villain. They share a calendar.

Mike Krieger left Figma’s board, then Claude Design shipped

Anthropic CPO Mike Krieger resigned from Figma’s board on April 14. The 8-K filing said the resignation was “not due to any disagreement.” The Information reported the same day that Anthropic’s coming Opus 4.7 release would include design tools competing directly with Figma. Three days later, Anthropic shipped Claude Design.

The product is what it sounds like. Generate prototypes, slides, mockups, and websites from natural language. Read your codebase or design files to apply company design systems automatically. Export to Canva, PDF, PPTX, HTML, or live URLs. Pass structured handoff bundles to Claude Code. Available as a research preview to Pro, Max, Team, and Enterprise tiers.

Anthropic’s framing was that Claude Design is “complementary, not competitive” with existing design tools. But the market disagreed. Figma stock fell roughly 7% on launch day, settling at $18.84 from a prior close of $20.32. The stock hit its all-time low of $16.69 a week later on April 24. Through April it was down more than 55% YTD, and roughly 88% from its post-IPO high of $142.92. Adding to the pressure, Figma’s DEF14A proxy filing on April 22 disclosed CEO Dylan Field’s 2025 compensation at approximately $864 million, driven by stock-price-hurdle RSUs that vested before the crash.

The launch videos and the “Figma killer” takes both got ahead of what’s actually shipping. Claude Design is not yet a credible Figma replacement for production work. Constellation Research VP Liz Miller put it well: “Just as master painters have different brushes they use for different things, you are never going to use Claude for design to create your finished masterpiece.” Early hands-on reports call the outputs “visually interesting” rather than analytically usable on real codebases. The collaborative canvas, the multiplayer cursors, the design system graph that millions of teams already maintain in Figma, none of that is replicated.

What Claude Design does compete for is the first-draft layer. The brief-to-comp loop. The “give me 30 explorations of this landing page” task. The slide deck mocked up in twenty minutes for tomorrow’s stakeholder review. That work used to live in Figma. It now has a credible alternative that costs $20 a month and lives inside the same chat where you do the rest of your thinking.

Figma kept shipping through this. Make kits and attachments on April 2. Figcade Fun Day on April 8. AI administration for Enterprise on April 21. Make pay-as-you-go billing on April 21. Make on iOS and Android on April 22. Config 2026 is confirmed for June 23 to 25 at Moscone with around 10,000 attendees expected. Whatever Figma’s response to Claude Design and Google’s Stitch will be, it lands there. And let’s hope it will be something meaningful, not another “draw” feature.

The first-draft layer is what AI labs are claiming. The collaborative canvas, the design system graph, the institutional knowledge baked into your team’s component library, that’s still yours. The implication isn’t that Figma is dead. It’s that the work that used to anchor your day in Figma (the explorations, the mockups, the quick deliverables) now has a strong substitute that doesn’t open Figma at all.

The capex flywheel that pays for itself by eating jobs

A single week tells the structural story. April 23: Meta announced 8,000 layoffs (10% of workforce) and closed 6,000 open roles, citing “continued effort to run the company more efficiently and to allow us to offset the other investments we’re making.” Same day, Microsoft announced its first-ever voluntary buyout program in 51 years, eligible to roughly 7% of US staff.

The other side of the same week: Meta’s projected 2026 capex was raised to $125-145 billion at its April 29 earnings call (versus $72 billion in 2025). Combined big tech AI infrastructure spending for 2026 is roughly $700 billion.

Challenger Gray’s April 2 report showed AI cited as the cause of 25% of all March cuts, the first time AI was the leading stated reason in Challenger’s history. AI was 5% of cited reasons in 2025. Ten percent in February. Twenty-five percent in March.

The independent productivity data does not support the narrative. Goldman, NBER, MIT, PwC, and IBM data all converge on the same pattern: most enterprises report no significant AI productivity gain. Marc Andreessen called AI “the silver-bullet excuse.” Sam Altman put it more directly: “There’s some AI washing where people are blaming AI for layoffs that they would otherwise do.”

The most defensible reading: the $700 billion capex commitment is the load-bearing structure. The AI productivity story is the wrapper. Lenny Rachitsky’s analysis of TrueUp data shows roughly 5,700 open designer roles globally, flat since early 2023, while PM and engineering roles have grown since 2024. The hiring market isn’t punishing designers because AI replaced design. It’s punishing them because AI restructured the workflow that design used to occupy.

The Vibe Coding Security Reckoning

For about eighteen months, vibe coding tools were absorbing a category of work that used to require engineering teams. Indie founders ship MVPs in afternoons. Designers prototype with real backend logic. Marketing teams build internal apps without filing a ticket. The trade was speed for safety, and most of us didn’t read the fine print. April was when the fine print got read out loud.

On April 20, security researcher @weezerOSINT publicly disclosed that any free Lovable account could read the source code, database credentials, AI chat histories, and customer data of every project created before November 2025. The vulnerability was a Broken Object Level Authorization bug. Lovable’s API granted access without checking whether the requester owned the resource. Free tier accounts, no special access needed. weezerOSINT noted that Nvidia, Mirosoft, Uber, and Spotify employees all had accounts in the affected pool.

Lovable’s initial response said there was no “data breach.” Three days later, the company disclosed it as a “permission regression.” A HackerOne report filed March 3, 2026 had been triaged and marked as duplicate, and never fixed. Forty-eight days of exposure between the original report and weezerOSINT’s public disclosure. Lovable’s most recent reported valuation: $6.6 billion.

The day before, on April 19, Vercel disclosed an unrelated incident. An attacker compromised a third-party tool used by a Vercel employee, then pivoted into internal Google Workspace and cloud environments. The chain matters here. The breach didn’t start at Vercel. It started at a tool Vercel trusted, and that trust was the lateral movement vector.

These two disclosures landed inside the same week. They share a structure. Tools that grew on speed-to-ship velocity, with security postures that hadn’t matured at the same rate, getting tested in production on a calendar they didn’t choose. The HackerOne triage at Lovable is the journalism. The cross-tool pivot at Vercel is the pattern.

One bug isn’t a market verdict, and Vercel responded fast and disclosed publicly. But the broader question is structural. Vibe coding tools now handle real money, real client data, and real production workloads. The security regime didn’t grow with the responsibility, and the disclosure cadence is starting to catch up.

Cursor’s $50 Billion Round and the SpaceX Option

In mid-April, Cursor was on track to close a $2 billion Series E at a $50 billion pre-money valuation, co-led by Andreessen Horowitz and Thrive Capital with Nvidia participating. Sacra estimates the company hit $2 billion ARR in February 2026, up from $100 million in January 2025, the fastest B2B scale-up on record. The round was oversubscribed.

A few hours before the round was set to close the week of April 22, SpaceX posted on X that it had secured an option to acquire Cursor for $60 billion later this year, or alternatively to pay $10 billion for a development partnership running on its Colossus supercomputer. The $10 billion is guaranteed even if SpaceX walks. Cursor halted the Series E discussions within 24 hours.

The structure tells you what each side cares about. Cursor pays retail prices to Anthropic and OpenAI for the models that power its product. Those same labs ship Claude Code and Codex, which compete directly with Cursor. Multiple sources estimate Cursor was spending close to 100% of revenue on third-party model inference until its proprietary Composer model started compressing margins in late 2025. The $2 billion Series E wouldn’t have been enough to reach cash-flow breakeven; another raise was already coming. SpaceX, meanwhile, just merged with xAI and is widely seen as having an AI lab without an AI product. Cursor fixes that in one move. SpaceX is also delaying the actual acquisition until after its summer IPO, so it can finance the $60 billion in publicly traded stock.

Investors love optionality, founders love price tension, and SpaceX just bought time to defer the decision until after its IPO. The fastest-growing AI software company on record couldn’t close a $2 billion round on its own terms when a strategic buyer wrote a bigger check. The model-supply economics were already eating its margins, and the path to independence required raises bigger than venture capital alone could provide.

Application-layer companies whose long-term margin depends on which lab’s model they route to don’t get to make that decision freely. The cost of the model layer underneath dictates it. We’re entering an era where the design tools we use depend on financing structures we don’t see, and on strategic buyers who can write checks that pure financial investors can’t.

Apple’s Transition to Wearable AI

On April 20, Apple announced Tim Cook will become Executive Chairman on September 1. John Ternus, 50, currently SVP Hardware Engineering, takes over as CEO. Ternus’s promotion is the part of the announcement that mattered.

Ternus has run Apple’s hardware engineering since 2021, which means every silicon decision, every battery decision, every camera and sensor decision for the iPhone 15, 16, 17, and Air, the M-series Macs, and the early Vision Pro shipped through his organization. He’s a hardware CEO inheriting a company at the moment its hardware bet matters more than its software bet for the first time in fifteen years.

The signals are all in the same direction. Bloomberg’s Mark Gurman reported four smart-glasses frame styles in testing, with production targeted for December 2026 and a launch in early 2027. Apple reportedly acquired Q.ai for over $2 billion to build subvocal interaction into AirPods Pro 3, paired with IR cameras. WWDC 2026 (June 8 to 12) promotional graphics teased an iOS 27 Siri redesign with a “Search or Ask” prompt in the Dynamic Island. The Vision Pro line has reportedly been deprioritized in favor of glasses-form-factor work.

Apple is positioning for the post-screen interaction era. The CEO change matters because Cook scaled the iPhone economy and Ternus knows how to ship novel hardware. The macro-environment is right for it. Meta’s Ray-Ban partnership has demonstrated demand for lightweight smart glasses, the AI lab race has produced models good enough to power ambient interfaces, and the smartphone supply chain has saturated.

Continuity is the easier read. Cook is staying as Executive Chairman, and the day-to-day will look continuous. But the signal is clear. Apple’s next platform isn’t a phone or a tablet. It’s wearable AI hardware that talks to you instead of being looked at, and the company just promoted the person whose career is shipping novel hardware to lead it.

Handpicked Highlights

👉 Emil Kowalski: Agents with Taste. Practical case for packaging design taste into Anthropic skill files. Kowalski breaks down why specific animation choices feel right (scale(0.95) instead of scale(0), easing flowcharts, duration guidelines), then converts each rule into structured input a coding agent can follow. His full design-engineering skill is installable via npx skills add emilkowalski/skill. The clearest answer I’ve read to the question of how taste survives the handoff to an agent.

👉 Garry Tan demos GStack on Y Combinator. YC President walks through GStack, his open-source toolkit that turns Claude Code into a multi-role engineering team via skills (Office Hours, Design, Code Review, QA, browser testing). The Office Hours skill is modeled on real YC partner sessions and pressure-tests your idea before you write a line of code. Free on GitHub. The clearest demonstration of skill-based agent teams I’ve seen this month.

👉 Josh Puckett: Melt Effect. A working tutorial on feTurbulence + feDisplacementMap for organic, hand-drawn-feeling distortion in SVG and CSS. Interactive sliders for every parameter, copy-paste filter, and a prompt at the bottom you can hand directly to a coding agent. Puckett also runs Interface Craft, his library “for those committed to designing with uncommon care.” This is what designers-who-build actually ship.

👉 Brian Lovin on Dive Club: How to level up with AI as a designer. Brian Lovin (Notion design) walks through his current AI tool stack, his Notion prototyping playground, why he’s back on Cursor, and how he thinks about career strategy for designers in the AI era. Includes the bookmarking side project Shiori he built solo. The most specific picture of a working designer’s AI process I’ve watched this year.

👉 Designer Tom interviews Diego Zaks at Ramp. Ramp is reportedly “the most AI-installed company in the world”: Anthropic visited the office because Ramp was using Claude Code more than Anthropic itself. Zaks (Head of Design) covers the four levels of AI fluency, how design changes when everyone is a builder, the 99.5% installed adoption story, and Glass (Ramp’s internal AI). The organizational counterpart to the individual-designer videos above.

👉 Gabriel Valdivia: I built a second brain out of markdown files. Fractional design partner Valdivia built a personal context layer pulling from Gmail, Slack, iMessage, Figma, Calendar, Granola, and Apple Health into a git repo of markdown files, plus 15 custom Claude Code skills that read, write, and cross-reference. The identity-profile section is the unsettling part: the system noticed his email tone with one client had shifted from enthusiastic to transactional before he had consciously admitted he was losing interest in the engagement. A mirror that gets sharper over time.

Three Moves You Can Make This Week

1. Audit which design tasks the labs now compete for directly. If your work is brief-to-comp loops, slide decks, marketing-page mockups, or first-draft explorations, that work now has a $20-per-month substitute that doesn’t open your design tool. Don’t panic. Just notice. Then ask: what part of my role is the labs not yet competing for? That’s where to invest your energy.

2. Get your content credentials in order before August 2. The EU AI Act’s Article 50 transparency obligations take effect August 2, 2026. AI-generated content must be labeled and watermarked in machine-readable format. Fines up to 15 million euros or 3% of global turnover. C2PA membership has crossed 6,000 organizations and is the de facto standard. Add Content Credentials to your export workflow now. Don’t wait until July.

3. Try Claude Design and Figma’s MCP and Paper.design in the same week. Build the same screen in each. Notice where each one wins, where each one fails, and where each one feels weird. The agent-era design stack is still forming. Designers who can talk specifically about the trade-offs between these tools will be valuable to clients in ways that designers who only know one tool won’t.

What April Revealed

In April, every layer of the AI economy got renegotiated at once.

The labs are building products that compete with the platforms they depended on. The vibe coding stack got publicly audited by its own bug bounty. The financing structures underneath the application layer bent to compete with the model layer underneath them. And Apple promoted the person who’ll ship the platform after the screen.

AI has restructured every layer of the workflow design used to occupy, faster than the productivity that would justify it has shown up. The collaborative canvas is still ours. The institutional knowledge in your design system is still yours. The judgment about which of fifty AI-generated options actually serves the user is still yours. The first-draft layer is gone. Everything above it is still where the work lives. And the next interface (wearable, ambient, voice-first) is the next brief.

I keep coming back to something Soleio said recently: “The future belongs to designers who build.” I read that as more than encouragement to learn code. When the labs replace your tool, when the platform you ship on gets breached, when the model layer underneath bends the financing on top of it, the designers who own the full creation pipeline (designing and building as one act, not two) are insulated from any single layer’s disruption. Yann-Edern Gillet’s Rosetta Stone metaphor for design engineering points the same direction: the artifact that translates between languages is the one that holds when one language changes.

The question I’m sitting with: what does my role look like when every layer of the stack is being renegotiated at once? I don’t have a tidy answer. I’m building habits around skepticism, verification, judgment, and end-to-end ownership because those don’t expire when the tool changes. I suspect that’s most of the answer.

If this edition gave you something, share it with someone who needs to read it. And subscribe if you haven’t already. May is going to test all of these patterns.

Sincerely,
Mykola Korzh

Multiple designers working in parallel across multiple product areas. Each one making reasonable decisions in isolation. Each one interpreting the design system slightly differently. Each one shipping work that looks fine on its own — until you zoom out and realize that “fine in isolation” is quietly becoming “inconsistent at scale.”

That’s where we were at GotPhoto. Not in crisis. Not with a visible quality failure. Just with a creeping awareness that as the team grew, our ability to guarantee consistency, accessibility, and design system compliance was becoming dependent on the wrong things: who happened to be in the critique session, whether a senior designer had bandwidth to review that week, and whether anyone had caught that a component was hand-built rather than a real DS instance before it went to engineering.

The honest trigger for this project was simple: we wanted every designer to have a reliable second eye before they even walked into a design critique — without needing a dedicated person or a separate team to provide it.

Not a gatekeeper. Not a bottleneck. A baseline. Something that meant designers could move faster, iterate with more confidence, and arrive at critique sessions already knowing their work met accessibility and design system standards. So the critique could be about the actual design decisions, not about catching the things a checklist should have caught.

That’s what we set out to build.

The product we were trying to protect

GotPhoto is a platform for volume photographers — photographers who run school picture days, sports seasons, and other large-scale events where a single job can mean hundreds or thousands of students, each with their own proof, their own parent, and their own purchase decision.

This is not portrait photography. A photographer using GotPhoto is managing a roster of subjects, coordinating with a lab, running automated email campaigns to parents, and monitoring conversion across an entire school or sports league — often across multiple jobs running simultaneously. The end customers are parents buying photos of their kids, frequently on mobile, frequently time-pressured, frequently guided only by an automated email with a link and a deadline.

That operational reality shapes everything about what good design means here. A photographer managing a 600-subject school job doesn’t have time to interpret a confusing affordance on shoot day. A parent landing on the storefront from an SMS link isn’t going to troubleshoot a broken package selector. When the UX fails, it fails loudly: in lost conversions, in support tickets, in photographers who don’t see the revenue they expected and start looking at alternatives.

The product has grown significantly. New features, new flows, multiple trios contributing to the same design system. When a product scales like this, quality degrades in two distinct directions at once. Most teams only notice one of them.

The first is design system drift. Components detach from their source. Developers hand-build controls that look like the real thing but aren’t connected to anything. Naming conventions diverge across trios. None of this is visible to users in the short term, but it makes the product progressively harder to maintain, harder to hand off, and harder to trust as a shared contract between design and engineering.

The second is UX debt. Empty states that don’t explain what happened or what to do next. Affordances that suggest one action and deliver another. Cognitive load that accumulates across a long flow until users make mistakes that feel like their fault but aren’t. These live inside screens that may look perfectly correct from a component audit perspective, and they can sit undetected for months.

The critical insight that shaped everything we built: these two problems are not the same.

A detached button and a confusing error message don’t have the same owner. They don’t have the same fix. They don’t belong in the same conversation. But in almost every manual audit we’d run, they ended up in the same list, reviewed in the same meeting, resolved with the same vague outcome. That creates noise — and noise teaches people to stop paying attention.

What we needed was a way to look at the same product through two separate lenses, consistently, without it depending on who had bandwidth that week.

The decision to build rather than buy

Before committing to building anything, we looked at what existed. The tools available were either too generic, too shallow in their Figma integration, or treated design review as a visual comparison problem rather than a structural one. None of them understood the difference between a real component instance and a hand-built substitute that looked identical in an export. None of them could be trained on our specific design principles or our internal anti-patterns.

The decision to build wasn’t made lightly. It required investment from the design systems team, engineering collaboration, and a calibration period that wouldn’t immediately produce value. But the case was strong: we had specific standards, a specific product, and a specific class of problems that generic tooling would never understand as well as we could.

What we built and how it works

The system is a dual audit workflow built in n8n, connected to Figma’s API, and powered by a large language model running on AWS Bedrock.

The trigger is a comment. Any designer on the team can post /audit as a comment directly on any Figma frame. No separate tool to open, no form to fill out, no process to follow. Within about 30 seconds, a structured audit appears as a reply comment on that same frame — right where the design lives.

Under the hood, the workflow reads the Figma comment, identifies which frame was annotated, pulls the layer tree from the API, fetches the team’s design system documentation, runs the analysis, and posts results back — all without a human in the loop.

The key architectural decision: two completely separate analysis tracks, not a single model trying to do everything.

The deterministic track reads the Figma layer tree directly through the API. It runs a rules engine over the file structure: checking whether components are real design system instances or hand-built substitutes, flagging naming patterns that suggest a control should be a component but isn’t, and examining relationships between sibling elements to surface inconsistencies that are invisible in the visual export but obvious in the file structure. This track doesn’t guess or infer — it reads what is actually there. No AI involved. It either is an instance or it isn’t.

The AI track takes a different approach. It receives a structured text summary of the layer inventory alongside our design system documentation, UX principles, and common anti-patterns specific to GotPhoto flows. The model reviews this through a UX lens only: task flow, hierarchy, readability, cognitive load, confusing parallel actions, and obvious usability risks. Critically, it’s explicitly instructed not to comment on design system compliance — that work is already done by the rules engine, and the separation prevents the two finding types from bleeding together.

Both tracks produce structured output, which a merge step combines and formats into a single comment posted back into Figma. No separate report to open. No extra tool to check. No translation layer between the audit and the place where design actually lives.

A note on the technical stack: Figma exposes a native webhook for team-wide comment events. The workflow listens for any FILE_COMMENT event across the entire team — every file, every designer — and filters for /audit. The layer tree analysis happens via Figma’s Nodes API, which returns the full structural JSON of a frame including component IDs that reveal whether something is a real library instance or a detached copy. The AI runs through AWS Bedrock. Everything is orchestrated in n8n, which handles the parallel API calls, merging, and the reply posting.

What broke first

No system like this works well out of the first version. Mine definitely didn’t — and the failures were more instructive than any of the early wins.

The first problem was noise from false positives. The rules engine was initially flagging correct components as violations. An “Add” button that was a proper, real design system instance was getting reported as a detached control — because the detection logic was matching on name patterns alone, without verifying whether the node was actually an instance. Audit comments filled up with false findings, and designers started skimming past them.

When that happens, the system stops working regardless of how accurate the legitimate findings are. Noise destroys trust faster than silence does.

The fix required tightening the logic: the rules engine now checks the Figma node’s type directly — a real instance has a different structural signature than a copied frame — and a container frame that wraps a proper instance is skipped, not flagged. Getting there required running the workflow on actual GotPhoto screens, not invented test cases.

The second problem was the opposite: things the workflow should have caught, consistently missing. Detached controls built from frame primitives kept slipping through because they can look visually identical to real design system components in an export and sit quietly in the layer tree. The original detection path wasn’t specific enough. We tightened the name-matching heuristics, expanded the vocabulary of action names the engine looks for (the list grew from about eight to over fifty), and adjusted the sibling-relationship check so a detached frame sitting next to a legitimate DS button is much harder to miss.

Both failures pointed to the same underlying lesson: the reliability of this kind of system is not primarily a prompt quality problem. It’s a signal quality problem. When the rules engine passes better structural data into the AI, the UX findings become more reliable and more specific. The deterministic layer is what makes the AI layer trustworthy.

What will change for the team

Before this workflow existed, design reviews were episodic in the way most design reviews are. Their quality depended on who was in the room, how much context they carried, and whether the same standard was being applied across squads and across weeks. A finding that a senior designer would catch on a focused afternoon might sail through a Friday review with a full calendar. The bar was inconsistent — not because of skill, but because of bandwidth, timing, and the limits of human attention across a growing product.

Now, the baseline review exists before any human critique begins. Designers walk in knowing which components are real instances and which aren’t. Product managers see design system findings and UX findings tagged, and understand why those are different conversations with different owners.

Three things worth carrying from this

1. Separate design system integrity from UX quality before you do anything else.

They have different owners, different timelines, and different kinds of urgency. A DS finding is a contract violation — something was built outside the shared system and will drift further from it over time. A UX finding is a user experience problem — someone using the product will be confused or slowed down. Treating them as the same in a review creates recommendations that nobody owns clearly and nobody prioritizes with confidence. The two-lens structure isn’t a technical detail. It’s the foundation that makes the output actionable.

2. Calibrate on your real product, not on test cases you invent.

The false positive problem and the detection gap both appeared within the first few times of running the system on actual GotPhoto screens. Neither would have surfaced in controlled testing. Every product has its own class of edge cases that generic frameworks don’t anticipate: the specific naming conventions your team uses, the way your design system’s component families are organized, the kinds of shortcuts that appear under deadline pressure. Build in a calibration sprint with no expectation of production-ready output. The findings from that sprint are the most valuable input you’ll have for the next version. The workflow is connected to a knowledge base node which help in this case.

3. The AI is a copilot for consistency, not a judge of intent.

The workflow catches what the file structure proves and what the structured layer data shows. It doesn’t know whether a deviation from the design system was deliberate — whether a component was hand-built because the DS didn’t yet have what was needed, or because a deadline was tight, or because a designer made a considered exception for a good reason. That context lives with people, not in files.

What changes is that the conversation starts from a documented, consistent baseline. Human judgment operates on better information. That shift — quiet as it is — raises the quality of every review that comes after.

The goal when we started wasn’t to automate design review. It was to make the standard consistent regardless of who was in the room. A system that catches the same class of problem every time. That separates the two kinds of debt that accumulate in a scaling product. That delivers findings in Figma, where design actually lives — before the review begins, not instead of it.

The system still produces false positives occasionally. The calibration is ongoing. There are classes of problem it doesn’t catch — intent-dependent decisions, qualitative calls that require product context a file can’t carry. Those remain human work. They should.

But the baseline is consistent. The noise is lower. The signal is higher. And the conversation in sprint planning is about the actual design decisions, not about catching what a checklist should have caught before everyone sat down.

Leave a comment

AI doesn’t always “try harder” when you add detail. Usually, it’s the opposite — it often gets lost. While handling complex reasoning tasks, the accuracy can go down by as much as 70%. But lots of designers still treat AI like a black box: dump in requirements, hope for magic, refine endlessly when it doesn’t work. The problem isn’t “bad prompting,” it’s not giving AI the information it needs to think clearly.

As designers, we understand that the way in which you structure information has a direct impact on how people process it. The same principle applies to AI — except AI is even more sensitive to structure than humans are.

Context engineering is design thinking applied to AI — when you structure context like you’d design a system, AI becomes reliable and genuinely collaborative. When you don’t, you’re essentially asking someone to solve a puzzle while hiding half the pieces.

Why context matters more than commands

Research on large language models reveals something counterintuitive: more context often means worse performance. Writing quality decreases by roughly 40% when context length doubles. The pattern holds across models and tasks.

What does this mean practically? That massive brand PDF you uploaded alongside your design system documentation and user research synthesis? You probably made the AI perform worse, not better. It’s drowning in information, losing track of what matters, forgetting constraints you mentioned three paragraphs ago.

Anthropic’s research team defines context engineering as:

“Thoughtfully curating the smallest possible set of high-signal tokens that maximize the likelihood of the desired outcome.”

This is the opposite of how most people use AI. The instinct is to give it everything — every edge case, every constraint, every piece of research you’ve ever done on the user. But more isn’t better. What we need instead is the smarter curation.

Think of it like designing an interface. You don’t show users every possible action at once. You reveal information progressively, in context, when it’s relevant. AI needs the same consideration.

When context is properly optimized, the results are striking: AI completes design tasks with 40% higher accuracy compared to unstructured context. It’s the difference between a useful collaborator and a frustrating tool.

And this isn’t just some abstract idea — the numbers are starting to pile up:

Teams using AI with structured design systems report 62% fewer inconsistencies in their output and 78% improvement in workflow efficiency. Component generation becomes 40–90% faster when systems are properly trained. These are documented results from teams that made the shift from treating AI as a command-line tool to treating it as a system that needs thoughtful architecture.

Share

The four layers of context

If context engineering is design thinking applied to AI, then we need a framework for what “good context” looks like. Through research and practice, four distinct layers emerge — each serving a different function, each essential for reliable AI collaboration.

Layer 1: Design system (The Container)

Your design system is the container that holds everything else. When structured for AI, it provides the foundational vocabulary and rules that make consistent output possible.

What AI actually needs from your design system isn’t your Figma file or a PDF export. It needs:

• Color tokens as CSS variables (e.g., --color-primary-500)

• Spacing scale with clear ratios (e.g., 4px base unit, scale of 1, 2, 3, 4, 6, 8, 12)

• Example components showing tokens in use

• Semantic naming that reveals intent

That last point deserves emphasis. A token named --color-text-primary tells AI something fundamentally different than #1a1a1a. The first communicates intent and hierarchy. The second is just a value. AI can reason about intent. It can’t reason about arbitrary hex codes.

The most effective design systems for AI follow a three-tier architecture:

Tier 1: Primitives. Raw values. The actual colors, spacing units, type sizes. These rarely get referenced directly.

Tier 2: Semantic. Purpose-driven tokens that map primitives to meaning. --color-feedback-error, --spacing-content-gap, --text-heading-large. This is where intent lives.

Tier 3: Component. Pre-composed patterns that combine semantic tokens into reusable solutions. A “card” that brings together the right spacing, colors, typography, and shadows.

Research shows structured design systems achieve 47% faster development even without AI. The advantage compounds significantly when AI enters the workflow, because AI can actually parse and apply the system correctly.

Layer 2: Brand guidelines (The Constraints)

Brand guidelines traditionally live in PDFs that nobody reads after onboarding. Context engineering transforms them into operational constraints that AI respects automatically.

Teams report 45% improvement in brand consistency when AI is integrated with structured brand guidelines, alongside 65% reduction in manual brand management time. Those aren’t small numbers for organizations that struggle to maintain consistency at scale.

The key is structuring guidelines as explicit constraints rather than aspirational documentation:

• Lock critical elements. Logos, primary colors, core typography choices — these are non-negotiable and should be marked as such.

• Allow explicit flexibility. Layout variations, secondary color applications, messaging tone within defined parameters — these are areas where AI can explore.

• Define boundaries clearly. “Headlines in Inter Bold, 24–48px range” is actionable. “Headlines should feel bold and modern” is not.

The shift is subtle but profound: guidelines become rules the system enforces rather than documents designers reference. AI doesn’t forget guidelines the way humans do. But it needs them structured as constraints, not suggestions.

Layer 3: User research (The Anchor)

This is the layer most teams undervalue when working with AI. User research provides the anchor that keeps AI recommendations grounded in reality rather than generic best practices.

Without research context, AI generates variations. With it, AI generates informed variations that understand who’s actually using the product and what constraints matter.

Key elements to include:

• Accessibility requirements. Specific WCAG levels, known user limitations, assistive technology considerations

• User behavior patterns. How people actually move through the product, where they spend time, what they skip

• Edge cases and localization. Right-to-left support, long text handling, cultural considerations for international users

• Demographic considerations. Age ranges, technical proficiency, device preferences, context of use

This is the key difference between AI as “variation generator” and AI as “informed collaborator.” A variation generator gives you options, and an informed collaborator gives you options that respect real constraints about real users.

Layer 4: Workflow (The Staging)

The final layer addresses how you interact with AI — the structure of requests themselves.

Chain-of-thought prompting has emerged as one of the most effective techniques. Rather than asking for a final output directly, you structure requests as steps:

1. Analyze the current state

2. Identify the core constraints

3. Generate three approaches

4. Evaluate each against the constraints and recommend one

This serves two purposes. First, it produces better results because AI reasons more carefully when asked to show its work. Second, and more importantly for designers , it makes the reasoning transparent. You can spot errors mid-process rather than discovering them in final output. You can see which constraints AI prioritized and which it deprioritized.

For more complex strategic decisions, tree-of-thought prompting takes this further by exploring multiple reasoning paths simultaneously. You see the decision tree, not just the conclusion. This is particularly valuable for decisions where trade-offs matter and there’s no single “right” answer.

The difference between commands and context

The Command Approach: “Generate 5 checkout layouts.”

What you get: Generic options based on AI’s general training. Some might work. Most won’t match your system, brand, or users. Significant refinement required.

The Context Approach:

Foundation: Here’s our design token file and an example of our checkout pattern.

Constraints: We use our brand blue (#0052CC) for primary actions. Mobile-first required. WCAG AA compliance mandatory.

Upgrade to paid

Read more

“We’re not going to make Friday’s deadline.”

The Slack notification hit at 11 PM on a Tuesday. I sat there for a moment, then did what any responsible Head of Design would do: I panicked efficiently.

By morning standup, I had a plan. “Sarah, you’re doing animations, just stick to the established patterns. Ben, we need to cut the onboarding to three screens, it’s too complicated now. I’ll deal with stakeholders.” My tone left zero room for debate. We had two days. No time for discussion.

It worked. We shipped on Friday.

Then I noticed something odd. Our next few standups were… Quiet. People nodded more, suggested less. Ben, who usually challenged every design decision, just said “sounds good” to things he’d normally pick apart. Sarah stopped bringing those weird experimental ideas that sometimes turned brilliant.

I hadn’t suddenly become a dictator. I’d just gone into pacesetting mode to save a sprint, then never left. And without realizing it, I’d trained my team to stay quiet and execute.

It turns out that your leadership style will show up whether you choose it or not. The only question is whether you see it happening.

Leadership styles in 90 seconds, and why we keep reinventing the same idea

For most of history, people believed leaders were just born that way (known as the Great Man Theory). The Great Man Theory dominated the 19th century. Look at Bismarck, Queen Victoria, Abraham Lincoln — clearly they had something special, some innate quality that set them apart. You either had it or you didn’t.

This was philosophically satisfying, but practically useless, as it didn’t actually help anyone become a better leader.

By the mid-20th century, researchers shifted focus to behaviors. Forget traits and think about what effective leaders actually do. They set direction, they coach, they delegate, they inspire. The list of leadership behaviors kept expanding, but nobody could answer the obvious question: when should you use which one?

That’s when contingency theories showed up. The answer, it turned out, was “it depends.” Different situations need different approaches. A crisis demands something different than a brainstorming session. A junior designer needs different leadership than a senior one. Context matters more than we’d admitted.

The modern view goes further: good leaders don’t just have one style. They build a range and switch deliberately. This matters especially in startup environments, where you might need to be a coach on Monday, a pacesetter on Wednesday, and a democratic facilitator by Friday.

The best leaders don’t know just one style of leadership — they’re skilled at several, and have the flexibility to switch between styles as the circumstances dictate.
Daniel Goleman, the author of “Emotional Intelligence”

Well, except most of us don’t actually do this. We have defaults. We fall into patterns, especially when stressed. And we usually don’t realize which mode we’re in until we notice our team acting differently.

A practical map of modern leadership styles

Here are the modes you’ll actually encounter in startup life—these are six leadership styles described by Daniel Goleman. Each has a place. Each has a price.

Upgrade to paid

Read more

Mykola here. March got political.

This month’s stories connect through one thread: trust turned into a product decision. An AI company said no to the Pentagon and became the most downloaded app in America. 45,000 tech workers lost their jobs to a forecast. Figma opened the canvas to agents. And 1.5 million users proved they’ll choose tools based on values, not just features.

The Company That Said No Became the Number One App

Anthropic signed a $200 million contract with the Pentagon in July 2025 and was the first AI lab to deploy on the agency's classified networks. Negotiations broke down when the Pentagon wanted Claude on its GenAI.mil platform without restrictions. CEO Dario Amodei drew two red lines: no mass surveillance of U.S. citizens, and no autonomous weapons fire. On February 27, the Pentagon designated Anthropic a "supply chain risk," blocking federal agencies and military contractors from using Claude. That label is reserved for Chinese state-affiliated firms. The next day, OpenAI signed a deal to provide AI services on those same classified networks.

The public responded within hours. The #QuitGPT petition gathered 1.5 million supporters. ChatGPT uninstalls surged 295% overnight. On March 3, Sam Altman told CNBC: "We were trying to de-escalate things and avoid a much worse outcome, but I think it looked opportunistic and sloppy." He amended the contract.

Claude hit number one on the U.S. App Store on Saturday, March 1. Daily signups broke all-time records for a week straight; paid subscribers more than doubled since January.

On March 9, Anthropic filed two federal lawsuits against the Trump administration. Dozens of employees from OpenAI and Google DeepMind, including Google chief scientist Jeff Dean, signed a public brief supporting their competitor. Microsoft filed its own supporting brief. Pentagon CTO Emil Michael responded on March 12: Anthropic would "pollute" the defense supply chain. An AI accountability march was organized for March 21 in San Francisco.

I want to be careful here. MIT Technology Review makes a credible case that Altman's amended contract doesn't prevent the surveillance use cases that triggered the backlash. Court filings from March 20 revealed the Pentagon told Anthropic the two sides were "nearly aligned," one week after Trump declared the relationship over. There are layers to this that a petition can't capture.

And yet: 1.5 million people made a product decision based on values. They didn't need a manifesto. One announcement showed them what the product stood for, and they acted.

I use Claude daily. I’ve built my workflows around it. I’m not American, and I don’t follow US defense politics closely. But I understand risk. Anthropic walked away from a Pentagon contract, got blacklisted, and sued the federal government. That costs real money and real relationships. Most companies would’ve quietly signed and moved on.

It doesn’t make Claude a better model. But it makes me trust the people building it more. I’m more willing to put client work through it, more willing to recommend it, more willing to build long-term workflows on top of it. That’s what trust as a product feature actually looks like in practice.

While all of this played out, Anthropic kept shipping. On March 20, Claude Code Channels launched with Telegram and Discord integration. You can message Claude Code from your phone and get results back. It’s Anthropic’s direct counter to OpenClaw. On March 23, Claude Cowork gained computer use: Claude can now control your Mac, open apps, navigate browsers, fill spreadsheets. Dispatch lets you assign tasks from your iPhone, walk away, and come back to finished work. The company that said no to the Pentagon is also the one whose AI can now operate your computer while you sleep.

Build systems where the values are visible from the first interaction. "AI ethics transparency" is now a concrete UI discipline: communicating what the model will and won't do, before the user finds out in a crisis. The patterns for this don't exist yet.

Fired by a Forecast

Q1 2026: 45,000 tech layoffs globally, over 30,000 in the U.S. Amazon leads with 16,000 cuts. Meta trimmed 1,500 from Reality Labs. Block fired 4,000 people on March 1. That’s 40% of the company. Jack Dorsey built an internal AI agent called Goose over 18 months and decided the company can run with 6,000 instead of 10,000. Stock surged 20%. Atlassian followed on March 11, cutting 1,600 to “self-fund” its AI push, with cloud revenue up 26% and its Rovo AI assistant at 5 million monthly users. They were growing when they made the cuts.

Harvard Business Review published a study by Davenport and Srinivasan, surveying 1,000+ executives. Companies are reducing headcount in anticipation of AI's future impact, even though AI hasn't proven it can do those jobs. The layoffs are real. The AI replacement is speculative. CEOs at Ford, Amazon, Salesforce, and JP Morgan Chase have declared white-collar jobs will "soon disappear," and they're acting on that belief before the technology delivers proof.

Jason Lemkin at SaaStr coined the phrase "invisible unemployment": companies don't fire people for AI. They don't backfill when people leave. 66% of CEOs surveyed plan to freeze team size or reduce headcount in 2026. Oxford Economics calls these AI layoffs "convenient corporate fiction."

Both things are true at once. Companies are using AI as cover for restructuring they'd want to do anyway. And AI is making some roles redundant. Those two facts don't contradict each other. They make the math harder to read.

Lenny Rachitsky’s State of the Product Job Market report tells the design-specific story. Roles crashed from nearly 10,000 in early 2023 to a low of 4,341. They’ve since climbed back 32% to about 5,716. PM and engineering both bounced back after ChatGPT’s initial shock. Design is recovering, but it’s the slowest discipline to come back. The ratio of open PM roles to designer roles flipped in mid-2023 and keeps widening (PMs now at 1.27x). Lenny’s theory: AI lets engineers move so fast there’s less opportunity and less desire to involve the traditional design process.

NN/g’s State of UX 2026 describes who survives the compression: “adaptable generalists who treat UX as strategic problem solving, rather than deliverable production.” Junior designer roles are vanishing. Entry-level UX positions are disappearing while senior roles demand breadth across research, strategy, and AI interaction design.

You either work with AI tools or compete for a shrinking pool.

March 11: Three Companies, Three Futures

On March 11, 2026, three companies shipped three different visions of the same AI moment. Same day.

Perplexity announced "Everything is Computer.". It integrates with Gmail, Outlook, GitHub, Linear, Slack, Notion, Snowflake, Databricks, Salesforce. Perplexity's internal study of 16,000+ queries claims $1.6 million in labor costs saved, 3.25 years of equivalent work, in 4 weeks. (I'll note: those are self-reported figures. The methodology for converting queries to "years of work" isn't transparent. Treat as a marketing claim until someone else verifies it.)

OpenAI published new agentic primitives in its Responses API, giving developers tools to build autonomous agent workflows.

Anthropic launched The Anthropic Institute, consolidating its Frontier Red Team, Societal Impacts, and Economic Research teams under one roof. Co-founder Jack Clark leads as Head of Public Benefit. They hired Matt Botvinick from Google DeepMind and Yale Law School to work on AI and rule-of-law.

Perplexity shipped the agent. OpenAI shipped the tools. Anthropic shipped the question of whether either is safe.

Perplexity's CEO Aravind Srinivas put it this way: "When you have highly accurate AI search, an orchestration harness of 20 frontier models, and agentic internet access, AI is the computer." That's a product thesis, and the rest of the industry is heading the same direction. An always-on computer that acts for you while you're asleep.

The shift is from designing interactions to designing trust signals, audit trails, and "what happened while you were away" dashboards. Ambient computing requires ambient design. Most teams haven't started building it. The interface for a computer that acts on your behalf while you're gone is a new design brief, and the patterns for it are unwritten.

Share

Figma vs. The Community That Made It the Standard

On March 11, Figma launched its AI credits monetization model. On March 18, hard enforcement of monthly seat credit limits began. Full seat users on Professional plans get 3,000 AI credits per month. Organization and Enterprise plans can now enable pay-as-you-go. Professional plan support for that? Delayed to May 2026.

Morgan Stanley analyst Elizabeth Porter calls Figma "the industry standard." Design community forums tell a different story. Users report Dev Mode seat costs could increase 10x. FIG stock is at $21.78 as of March 24, down 85% from its post-IPO peak of $142.92 on August 1, 2025, and below its $33 IPO price.

Figma also acquired Payload CMS to accelerate its content management roadmap. Figma Sites now supports collections, CMS pages, and CMS lists, though it still lacks nested URL structures, a public API, and content staging.

Then, on March 24: Figma opened the canvas to agents. The new use_figma MCP tool gives Claude Code, Codex, Copilot CLI, Augment, Factory, Firebender, and Warp direct write access to Figma files. Agents can create and modify frames, components, variables, and auto layout, all wired to your existing design system. Figma also shipped “Skills,” markdown files that teach agents your team’s conventions and sequencing. Nine example skills launched on day one, including ones from practitioners at Uber and OpenAI. Free during the beta, usage-based pricing later.

This is a sharp reversal. On March 6, Figma’s MCP server was read-oriented. On March 24, it’s read-write. The speed matters. Paper launched its desktop app and MCP server on March 5 with 24 bidirectional tools and a code-native HTML/CSS canvas. Figma took 18 days to match on write access. Paper’s advantage is still architectural. Everything renders as real flexbox, real CSS properties, no conversion layer. Its MCP was write-capable from day one. Figma’s advantage is the installed base and the design system graph that millions of teams already maintain there. And Framer cut Figma-to-web production time by 70% via its 2026 Import Engine. All three are positioning as the agent-era design layer.

Figma's State of the Designer 2026 report says 91% of designers say AI improves their designs, and 89% are working faster. Frustration is concentrated in graphic design and illustration, where daily AI use sits at 40% compared to 65% for web developers.

I covered Figma’s valuation correction in January and its bet on taste in February. I wrote about Paper back in September when it opened signups. The pitch then was closing the gap between what designers create and what developers build. The pitch now is bigger: a design canvas that’s natively agent-ready, where your AI tools read, modify, and push changes back into the canvas directly. Figma just made the same bet, and it did it in 18 days. The race now is about which agent-first architecture wins.

Your tool choice is a strategic decision. Try both. Paper’s code-native canvas eliminates the design-to-code handoff entirely. Figma’s canvas write now lets agents build with your existing design system as source of truth. Framer’s Figma import makes switching cheaper than it was six months ago. The window to evaluate is open right now. Pricing structures will harden by summer.

Handpicked Highlights

👉 Scott Barker: How to Prepare for the Next Decade. Barker calls the 2020s “the Acceleration Decade” and offers ten ways to move through it with some peace and equanimity. Over 200,000 reads. Useful framing for anyone whose job description has changed three times since 2023.

👉 Lenny Rachitsky × Jenny Wen: The Design Process Is Dead. Jenny Wen is head of design at Claude and previously led FigJam and Slides at Figma. She argues the classic discovery-mock-iterate cycle is obsolete. Designers should act like internal VCs, spotting prototypes with energy around them that nobody can articulate yet and translating them into products. She covers her AI tool stack, the three archetypes she’s hiring for, and why chatbot interfaces may be more durable than most people expect. 77 minutes, worth the full listen.

👉 Soleio’s Design Hiring Playbook, packaged as an AI agent skill. An installable Claude Code skill that operationalizes Soleio’s design talent framework. Two modes: one for founders sourcing designers, one for designers positioning themselves. The insight: top design talent never responds to job postings. The skill helps both sides close that gap.

👉 Fin.ai: We Gave Claude Code to Everyone at Intercom. Not Just Engineers. Intercom rolled out Claude Code company-wide, equipped with internal skills and integrations. The finding: when non-technical people get the same tool engineers use, enhanced with company-specific intelligence, they don’t just use it. They build with it. Intercom calls this a structural change in how organizations work, not a productivity story.

👉 Paper Snapshot: capture production UI, paste it into Paper as editable layers. Chrome extension that grabs real HTML/CSS from any live page and drops it into Paper’s canvas. No screenshots, no conversion. Grab something from prod, paste it in, let Claude spin up six variations. The design-to-code gap works in reverse now.

👉 Linear: A Calmer Interface for a Product in Motion. Charlie Aufmann and Maxime Heckel walk through Linear’s latest UI refresh. The core moves: dim the sidebar so it stops competing with your content, compact the tabs, simplify the icons, soften the borders. A two-person team shipped it using coding agents and internal tooling (a dev toolbar with feature flag toggles, a custom theme editor that exports token values as JSON). They see it as preparing the interface for agentic workflows. Worth studying for the process as much as the result.

👉 Karl Koch: 10 Principles for Fluid UI. The best design engineering article I’ve read this month. Physics-based motion over time-based easing. Every animation must be interruptible. Direct manipulation over indirect control. Velocity preservation across gesture boundaries. Each principle has an interactive demo you can play with on the page. Published in February, updated March 23. Bookmark this one.

👉 Agentation: visual feedback for AI coding agents. Click any element in the browser, write your feedback, and Agentation generates structured Markdown with CSS selectors, source file paths, React component tree, and computed styles. Your agent knows exactly which element you mean and where to find it. MCP integration lets agents read annotations in real time and respond back. Free for internal use. By Benji Taylor, Dennis Jin, and Alex Vanderzon. v3.0.1.

Share

Three Moves You Can Make This Week

1. Audit what your AI product refuses to do, and make that visible in the first interaction. The QuitGPT movement proved that 1.5 million users form product opinions based on values. If your product uses AI, its limits and refusals should be accessible from the first screen. Build a prototype of an "AI ethics card" that communicates what the model will and won't do.

2. Prototype a “what happened while you were away” dashboard for any agentic tool you’re working on. Perplexity’s always-on computer, Cursor’s background agents, and Claude’s new computer use all point to the same pattern: AI acts while you’re away. The interface for reviewing those actions is the defining design problem for agentic tools in 2026. Start sketching it now.

3. Test agent-driven design this week. Both Figma and Paper now let AI agents write directly to your canvas. Try Figma’s new use_figma MCP tool with your existing design system (it’s free during beta). Download Paper’s desktop app and connect its MCP server to Claude Code or Cursor. Spend an hour with each. The agent-era design stack is forming right now, and the evaluation window won’t stay this open.

Since Last Month

The SaaS-pocalypse is accelerating. In February, I covered the initial $285 billion software value wipeout. It's gotten worse. Microsoft is down 16%, Adobe down 27%, Salesforce down 30% year-to-date. Cisco (infrastructure) is rising on the same days software falls. Investors have moved from "AI will disrupt SaaS" to "SaaS is disrupted."

Tailwind CSS stabilized, with irony intact. January's lead story covered Tailwind's 80% revenue drop. Emergency sponsorships from Google, Vercel, Lovable, Gumroad, and Macroscope stopped the bleeding. The underlying problem (AI trained on Tailwind docs breaking Tailwind's own funnel) remains unsolved. AI killed Tailwind's revenue, and Tailwind now survives on sponsorship from the companies whose AI killed it.

The OpenClaw arc completed. February covered its growth and Steinberger’s OpenAI hire. March closes the loop: 250,000 GitHub stars in 6 weeks, Chinese government restriction (March 10), and a critical CVE in related tooling (disclosed February 25). Anthropic shipped Claude Code Channels on March 20, adding Telegram and Discord integration that gives Claude Code the same always-on messaging that made OpenClaw viral. The full lifecycle of an open-source project played out in 8 weeks, and the incumbent absorbed its core feature.

AI coding agents crossed a threshold. Claude Code is at 46% developer preference, far ahead of Cursor at 19% and GitHub Copilot at 9%. The Pragmatic Engineer survey of 906 engineers found 95% use AI coding tools weekly. Cursor shipped Background Agents (isolated VMs, test their own code, produce merge-ready PRs). Coding agents have moved from "assists you while you type" to "executes for hours while you sleep."

AI copyright litigation escalated. Bartz v. Anthropic settled for $1.5 billion. A federal judge ordered OpenAI to produce 20 million anonymized ChatGPT conversation logs. 70+ active AI copyright cases. The EU Parliament voted 460-71 for mandatory training data licensing. Content provenance is a near-term design requirement for any team shipping AI products.

What March Revealed

In March, users showed they have opinions about ethics, and those opinions have consequences.

Claude, GPT, Gemini, etc. can all write, code, plan, and reason. The capability gap has closed. Users are choosing based on whether they trust the people building it. That’s a product question.

This changes the brief. The interfaces that will matter most in the next year are the ones that make trust visible. Your product’s refusals should be clear from the first interaction. Its limits should be findable before users discover them in a crisis.

The QuitGPT movement is real data, and OpenAI still has 200+ million weekly active users. The layoffs are real, and 91% of designers say AI is making their work better. The trust gap is real, and it’s also something you can design for. March made the problem visible. That’s step one.

Most of that work hasn’t been done yet. I’m figuring out my part of it. I suspect you are too.

If this edition gave you something, share it with someone who needs to read it. And subscribe if you haven't already.

Sincerely,
Mykola Korzh

Last edition, we talked about what happens when you stop being a user of AI and become the architect of it, designing AI-powered experiences for your own users.

Today, we flip the lens inward.

We’re going to talk about what happens when you stop treating Claude like a search engine and start treating it like a new hire. A hire you actually bother to onboard properly.

Most designers I speak to use Claude the same way every single day: open a chat, paste something, ask a question, get an answer, close the tab. It works. But you’re using maybe 20% of what this tool can actually do.

The feature that unlocks the other 80%? Almost nobody in the design community is talking about it yet.

It’s called Claude Skills.

Professional AI Prompt Kit for UX Designers

Before we start this edition, I have a special learning material for you. Want to skip the learning curve and start using production-ready prompts immediately? I’ve created a comprehensive AI Prompt Kit specifically for UX designers and researchers who want to leverage AI as a strategic tool, not just a content generator.

Get the AI Prompt Kit for UX Designers

✨ A quick note for our Pro subscribers: If you are a member of the Eidos Design Community, make sure to use the link at the end of this article to claim your exclusive 35% discount.

Now let’s get back to Claude Skills.

Wait — Isn’t This Just Prompting?

No. And the difference matters a lot.

A prompt is a one-time instruction. You type it every session. It disappears when the tab closes. Even if you save it in a Notion doc, you’re still copy-pasting it manually every time you need it.

A Claude Skill is a packaged, persistent specialization that Claude automatically loads whenever it’s relevant to your task. You build it once. It lives in your Claude account. And every time you start working on something that matches its purpose, Claude silently picks it up and becomes a better version of itself — without you doing anything.

Think of it this way: every time you start a new chat with Claude, you’re essentially hiring a brilliant generalist who knows nothing about you, your product, your users, or your methodology.

A Skill is your onboarding document for that hire. Except once you write it, you never have to run the onboarding again.

What Skills Actually Are (Under the Hood)

Here’s the part that will appeal to the technically curious among you.

A Claude Skill is not a setting or a toggle. It’s a file — specifically a SKILL.md file, structured as a Markdown document with a YAML metadata header at the top.

That file lives inside a folder. You zip the folder. You upload the zip to Claude. Done.

Claude scans your available Skills when you start a task. If the task matches a Skill’s description, Claude loads it — quietly, automatically, in the background. You just notice that the output is suddenly much sharper and more calibrated to your context.

This is what Anthropic calls progressive disclosure: Claude first reads only the lightweight metadata (name + description) to decide if a Skill is relevant. If it is, it loads the full instructions. This keeps things fast without sacrificing quality.

The best part? Skills are portable. A Skill you build for Claude.ai works identically in Claude Code and through the API. Build once, use everywhere.

Setting It Up: The Actual Path

Before you can use Skills, there’s one quick prerequisite.

Read more

A couple of days ago, I saw this post by Tobias van Schneider in my LinkedIn feed.

I feel the same way. As well as plenty of other designers out there who started their careers years ago. We were designing with Photoshop, Sketch, Figma; every tool was another multiplier, changing the design environment. But the act of design, in its essence, stayed there, unchanged.

In this context, AI is another multiplier that makes you faster and more effective. But it will not make you a better designer. The act of design, and the the judgment, and the taste — are the constants.

Then, a more junior specialist asked me: “If I use AI to design, will I not lose my skills?” And I thought about an interesting parallel involving modern pilots in aviation.

The thing is, aviation has become so safe, thanks to automation, systems that repeat themselves, streamlined processes and protocols. In principle, an automated system could take over the entire flight today, from takeoff to landing. And yet, this doesn’t happen. We can’t, and we don’t want to, entrust our lives to a computer. We want pilots (people) who, in an emergency, can take control and make decisions.

That’s why pilots continue to thrive in modern aviation, and to keep their skills sharp, they always handle takeoff and landing manually, by turning off the autopilot.

It seems we’re as tech specialists at roughly the same point. Design will increasingly shift toward designing with prompts, and they’ll be created not only by designers, but also by developers, managers, marketers, and others. So, it’s quite likely that, to avoid losing our core skills and vision, we’ll have to handle takeoffs and landings ourselves.

This issue, we’re talking about deskilling. Honestly. And about what designers who genuinely care about their craft can do about it.

In this issue:

• When the autopilot lands the plane. A look at what AI tools are eroding in the design profession, and why the most valuable skill in 2026 might be the one you can’t prompt for.

• Pencil.dev review. A canvas that lives inside your IDE — the clearest attempt yet at collapsing the design-to-code wall, with everything that implies.

• The cockpit problem What NASA’s research on pilot deskilling teaches designers about the real cost of letting automation take the wheel.

I. When the Autopilot Lands the Plane

Insight

Here’s a story circulating in design communities right now. A design lead reviews portfolio work from recent graduates. The quality looks stunning. Polished, pixel-perfect, confident. Then, she asks candidates to walk her through a decision. Why this grid? Why this type scale? Why this interaction pattern? And then: silence. Not rudeness. Not laziness. Just the honest answer: “Claude did it, and it looked right.”

This is deskilling. And it’s not unique to design.

Deskilling is what happens when a tool gets good enough to execute a job that previously required deep human expertise. The term comes from labor economics. Harry Braverman used it in 1974 to describe how industrial machinery reduced craftsmen to machine operators. And the knowledge didn’t disappear, however it moved into the machine.

What’s happening in design right now is structurally identical. When Figma’s AI can auto-layout a component, when Claude can generate a full screen from a prompt, and when Pencil.dev can translate a rough sketch into production-ready React before you’ve finished your second coffee — the execution layer of design is migrating into the tool. Fast.

And that’s worth sitting with for a moment.

Craft knowledge in design is deeply perceptual. The ability to feel that a 4px spacing increment is wrong before you can articulate why. The instinct to know that a typeface is carrying the wrong emotional weight for a brand. The judgment to sense that a user flow has one step too many, even before testing it. These things you learn only by doing, struggling, getting it wrong, fixing it, and doing it again. Hundreds of times.

For a generation of designers entering the field today, many of those hundreds of repetitions are being skipped.

The practical stakes are real. Research from NASA’s Human Systems Integration Division has documented a parallel phenomenon in aviation for years: pilots who rely heavily on automation lose the manual flying proficiency that matters most when things go wrong. The skill erodes slowly, in the background, invisible until the moment it’s urgently needed.

Designers are entering their own version of this. The “manual flying” skills — layout composition, visual hierarchy construction, spacing rhythm, typographic judgment, are being practiced less and less by newer practitioners. In low-stakes, fast-moving contexts, that’s manageable. It becomes a real problem the moment complexity demands genuine craft.

So what do we actually do about it? No, I absolutely don’t say that you need to reject AI tools. But we need to be deliberate about which skills stay human. Think of it like a musician who uses production software. The best ones still know how to play their instrument. The software amplifies that knowledge rather than replacing it. But they made a conscious choice to keep foundational practice alive alongside the tool.

Designers can do the same. A few practices worth protecting deliberately:

Sketch by hand before you open any tool. Even badly. Especially badly. The rough sketch forces compositional thinking that a prompt skips entirely. It trains your eye in ways that typing simply doesn’t.

Learn the rules you’re breaking. Grid systems, typographic scale, Gestalt principles, color theory. These will not turn into historical artifacts. They’re the grammar of visual language and understanding them makes AI-assisted output better, because you know when the output is wrong.

Explain your decisions out loud, regularly. If you can’t articulate why a layout works, you’re just pattern-matching, and not really designing. Articulation is how instinct becomes craft.

Work in constraints sometimes. Three colors. One typeface. Constraints are uncomfortable. They’re also where creative judgment actually develops.

Sure, the best designers of the next decade will be the ones who use AI fluently and still know how to “land the plane manually”. That combination — tool fluency plus foundational craft — is becoming rare. But it’s also genuinely powerful.

The autopilot is useful, but keep your hands on the controls.

Share

II. Pencil.dev: Design Mode for the Age of Vibe Coding

Product Review

Reminder: Product evaluation is done according to Don Norman's 3 levels of design.

The design-to-code handoff has been broken for as long as anyone can remember. Designers work in Figma. Developers work in their IDEs. Somewhere in between, pixel values mutate, spacing decisions get misinterpreted, and a remarkable amount of time disappears into the gap.

Pencil.dev is a genuinely interesting attempt to close that gap by eliminating it entirely. And I deeply believe the tools like this one, can (will?) replace Figma, if Figma is not fast enough in addressing these gaps.

So it’s a vector design canvas that lives inside VS Code, Cursor or Claude, with design files versioned in Git alongside your code. Draw something. Ask Claude Code to build it. Watch it land in production.

It’s new, currently free, and it raises some sharp questions about what the role of a designer actually is when the canvas and the codebase are the same thing.

Visceral level: 3/5
The visceral level is responsible for first impressions.

Pencil’s interface is rather clean and purposeful, clearly built by people with strong product instincts. The infinite canvas feels familiar for anyone who’s used Figma or FigJam, and the dark IDE-native aesthetic fits comfortably inside VS Code without fighting for attention.

That said, the first-impression experience is utilitarian rather than delightful. There’s no onboarding magic, no “welcome to a new way of working” moment. You install the extension, open a .pen file, and you’re in. For practitioners who already live in the IDE, that directness is a feature. For designers coming from a pure design background, the context switch is real and slightly jarring. First impressions feel more workbench than studio, and for a tool asking designers to rethink their entire workflow, a warmer entry point would earn more trust faster.

Behavioral level: 4/5
This level focuses on usability — how the product performs and whether it effectively solves user problems.

This is where Pencil earns its reputation. The core workflow — design on canvas, feed context to Claude Code via MCP, generate production-ready React or HTML/CSS — is genuinely well conceived. The MCP integration means Claude Code receives exact vector coordinates and token values rather than interpreting a screenshot, which closes the fidelity gap that has made every image-to-code tool before it ultimately frustrating.

Here I asked Pencil to design a simple mobile app with clocks for chess players. Then, I watched how Echo and Drift agents were designing it. They did in 5 minutes something that a human would do in hours.

Several things work particularly well:

• The Figma import preserves layout hierarchies and spacing values with solid accuracy.

• The bidirectional sync between canvas edits and code feels natural once you’ve adjusted to the paradigm.

• And the Git-native approach to design versioning solves a real problem that most design teams have been papering over with timestamp-named Figma duplicates for years.

Limitations worth knowing:

• Complex auto-layout configurations sometimes require manual cleanup after AI generation.

• The quality of generated code depends heavily on how clearly you structure your canvas.

• Ambiguous groupings produce ambiguous code. The tool rewards designers who already think in clean systems and hierarchies, and here the loop closes neatly back to the essay — the skills that make Pencil sing are the exact foundational skills that deliberate practice builds.

Reflective level: 4/5
The reflective level considers the long-term impression and deeper meaning of the design — how it aligns with the user’s identity and values.

Pencil is philosophically interesting.

It is purpose-built for a specific kind of practitioner: the designer who codes, the developer who designs, the solo builder who does both. In the hands of someone with strong foundational craft, it’s an accelerator. It removes handoff friction, keeps design and code in sync, and dramatically reduces the cognitive overhead of context switching. That’s real, meaningful value.

In the hands of someone still developing their visual judgment, it can become a shortcut that skips the exact thinking the work requires. The canvas is infinitely flexible. Claude is infinitely patient. Knowing what to put on the canvas in the first place — that still comes from somewhere else. From practice, taste, and from the deliberate cultivation of judgment that no prompt can shortcut.

I realize now that Pencil doesn’t resolve the deskilling question. But to its credit, by demanding clean design thinking as an input, it quietly rewards practitioners who’ve done the foundational work.

Overall: 3,6/5 ⭐

A genuinely forward-thinking tool that collapses the design-code boundary in ways that feel right for where the industry is heading. Best in the hands of practitioners who already know why their decisions work. For everyone else, it's most valuable when used alongside foundational craft practice, rather than as a replacement for it.

Share

III. The Cockpit Problem

A Dose of Inspiration

In 2013, the Federal Aviation Administration issued SAFO 13002, a Safety Alert for Operators with a quietly alarming message: pilots were losing the ability to fly manually. The automation was simply too good, and too available, for manual flying skills to stay sharp on their own.

NASA’s Human Systems Integration Division had been documenting this for years under the term “automation-induced complacency.” Pilots who relied heavily on autopilot from takeoff to landing were gradually losing the manual proficiency that matters most when automation fails — which it does, sometimes at genuinely critical moments. The finding wasn’t that autopilot was bad. Modern autopilot systems make flying dramatically safer in most conditions. The finding was about what happens to human skill when it stops being practiced. To sum up, we arrive at the simple fact that experience is not something you can simply possess, but something you must constantly cultivate.

Aviation’s response was deliberate and structural. The FAA began recommending that pilots hand-fly more often, particularly during lower-altitude, higher-complexity phases where manual flying develops the most skill. Airlines built manual flying time back into training programs. The industry designed practice back into a workflow that had quietly engineered it out.

The lesson for designers is to notice what you’re no longer doing, and decide consciously whether that matters. Some of what AI tools replace in the design workflow genuinely doesn’t need human attention: repetitive resizing, asset exports, writing component documentation. Fine to automate. But the cognitive work of composing a layout from scratch, resolving a visual hierarchy, or developing a type system with real intention — that work builds the judgment that makes every other decision better.

Design has its own version of manual flying hours. Build them in on purpose.

And this is it for today,

The anxiety is real. The tools are genuinely powerful. Both things are true at the same time, and neither cancels the other out.

What I hope you take from this issue is intention rather than worry. AI tools are extraordinary when held by someone who knows what good looks like. And that knowledge doesn’t come from prompts. Your real practice still matter, from getting things wrong, the quiet repetitions of craft that nobody sees but that shape everything you make.

Keep those hours. Guard them a little. Use the autopilot, but keep your hands on the controls.

If something here landed for you — or if you’re sitting with a completely different perspective — hit reply and tell. We’d genuinely love to know: which foundational design skills do you actively keep practicing, even when you don’t have to?

As always, this newsletter is free, but if you enjoyed it, please consider sharing it with a friend or two. Spreading the love is what it's all about, folks 🖤

Share

Sincerely,
Vadym Grin