Intent is one of my go-to coding workspaces. By default, it’s spec-driven and uses swarms of agents to execute the work, with a brainy orchestrator agent coordinating it all.

Ryan Mather, interviewing the product lead for Intent, designer-developer Amelia Wattenberger for AI Design Field Guide, asks how she designs when software behavior itself can change:

It’s a new dimension in which apps can be dynamic. We had image maps exported from Photoshop with a certain resolution, and then we were like, “wait, screens are going to be different sizes — this isn’t going to work anymore.” So we needed layout algorithms. Then users could interact and change what’s on the page — so we made them dynamic through time. Users had preferences — so we made them dynamic based on the user. And now there’s an additional dimension where even the app behavior itself can be completely changed - custom to you.

So designing now is a dance of, what are the primitives to add to the structure? Are we using bricks or another building block? And then the user can fully configure the app’s behavior, which I think is the only way to build a product now. Otherwise it’ll be stale in five months. Someone else will build a new app that does something around the workflows that people want.

Stable application chrome can provide continuity. In configurable software, Wattenberger locates that continuity in the objects people use to compose a workflow: the workspace that contains a task, the spec that humans and agents edit, and the subtasks that make delegation visible.

She describes what happens when those objects disappear:

I think about a straw that’s really bendy, and someone trying to do a thing with it — it’s just not a very powerful thing. Or clay — you can’t build super big things with clay, and you can’t go really quickly, because it’s infinitely moldable. Anything that’s generic is the jack of all trades, master of none. If you want something really powerful, you need some structure there. You need bones, you need muscles, some affordances. You can’t just be like, “oh, it’s a pile of goop, and stuff arises from the goop, that’s not what we all want.”

Mather then asks how far configurability can go. Wattenberger:

I have a feeling that applications as a paradigm will not last much longer, at least as the main way we interact with computers. Things will be way more modular and definitely decoupled from the data. There will also be a strong remix culture, because people don’t want to create everything they want from scratch, but they also want the ability to customize the things they use. So things are going to get super wacky.

OpenDoc, for example, imagined documents as containers for live, editable components supplied by different tools, rather than files owned by a single monolithic application. Computer scientists have been chasing variations of this modular model for years. AI, and the capabilities it gives users, adds a new dimension: the behavior of the application itself can now be remixed.

The startup grind is often the same: ship fast, but maintain a high bar of quality. At least that’s the sentiment. Those things are in opposition and the system incentivizes people to just move on.

Miguel Fernandez, writing for Slack Design, describes why shared standards matter:

Craft is subjective, until it isn’t. Disagreement surfaces the moment you have to define it. Is this interaction good enough? Is this component polished? Without shared standards, these discussions become battles of personal taste rather than principled decisions. You can’t argue craft in a document. You can only experience it.

That makes the quality bar a cross-functional working agreement rather than a designer’s private standard. Fernandez continues:

It seems like craft competes with velocity. Engineering and Product are often rewarded for shipping, not refining. Craft requires slowing down at key moments, which feels costly when measured against sprint commitments. The incentive systems work against craft, but this is a false trade-off: craft debt compounds just like technical debt, and eventually you pay for it in churn, reputation, and the slow erosion of what made your product special.

Fernandez then quotes Linear co-founder and CEO Karri Saarinen on the conditions beyond the individual:

“Craft is the mindset that creates quality. But it’s not enough. You need to have the right skills and ideas. You need individuals who take their profession and craft seriously, then build teams that work this way together, and have a company that creates the conditions for it. Not only incentivizing with deadlines and metrics, but also caring if the experience is good enough.”

At Apple, my boss Hiroki Asai, then the VP of Graphic Design, often gave me the same feedback: “This needs to be more considered.” Meaning, spend more time with it. Keep your quality bar high.

That memory came back while listening to Michael Riddering interview Charlie Deets, a former Safari designer now working on Dia, on Dive Club. Riddering:

It’s that extra loop and practice of consideration that I find often is the only way that I can get to simplicity.

I might have the right idea as my knee-jerk reaction. Like we put in a lot of reps, like that’s not uncommon for me. Sometimes I return back to the idea.

But then knowing that this is directionally correct, but then going through it one more time and say, “Okay, how what can I distill or cut or combine?”

Deets connects Riddering’s extra loop to Apple’s willingness to interrupt its own momentum:

Yeah, this is something I think Apple just does better than anyone else, and I think it’s partially because of sort of this one-year release cycle thing. At any point in that cycle you can say, “Is this really the right way?” And you can go back to the beginning.

And people almost are expect that disruption as part of the process. Like it’s very much part of the process to just say, “Actually we’re on the wrong path. Let’s start over from this position.”

Reopening the work also asks something of the team. Deets again:

And I think that requires a lot of confidence and it requires a lot of low ego or something.

That was Hiroki’s lesson, too. “More considered” meant that the work could be further iterated upon.

Quotes lightly edited for clarity.

Album-cover and gig-poster artists capture the feeling of music while building a visual identity around it. I respect anyone who can pull off both.

Paul Moore, writing for It’s Nice That, talks with artist and album-cover designer Robert Beatty about old versions of Photoshop, scavenged technology, imperfect memories, and the unexpected contrasts in his work. Beatty’s approach to working with musicians gets at the translation involved:

Honestly there’s not really a huge difference in the way I approach things based on the genre of the music, it’s more what the artist is trying to accomplish or get across than the way it sounds. It’s often the way the artist communicates their ideas or aren’t able to that really informs the way I approach making album artwork. It’s definitely rare that a musician has as much understanding and articulation when talking about visual art as they do music, which is I guess why people come to me to help figure out how to convey their music in a visual medium. I don’t know if having an understanding of both music and art really changes the way I make art for music, but I approach them the same way with a very improvisatory and open mind. And sometimes it’s the contrast between the music and the art that makes something interesting.

That contrast leaves room for the image to carry the music’s mood without illustrating the sound literally. Beatty describes the response he’s after in one line:

I’m trying to make something that works on an almost primeval level.

I love that idea: style can draw you in, but the image still has to connect before you’ve decoded its references. Moore’s full interview with Beatty also covers creative friction and making videos that move with music rather than simply decorating it.

Paul Bakaus says he helped turn Impeccable from what he calls a “vibed personal skill” into a design toolkit. He says hundreds of thousands of designers and developers now use it. Three of his techniques show how much of that improvement came from engineering around model behavior instead of polishing a prompt.

The first is “Make them argue · two blind reviewers beat one confident guess”:

For a concrete example, /impeccable critique, Impeccable’s design review command, runs both deterministic checks against your code (to detect stuff like low contrast quickly and decisively) and reviews the design like a human would. But early versions had a major flaw that produced bad critiques: hand the LLM the detector output up front and it skews BOTH ways:

1. detector noisy → condemns a strong page over fixable nits (false alarm)
2. detector silent → rubber-stamps a generic page (meaningless clean bill)

To debias, critique now spawns two sub-agents that never see each other’s work: A = an LLM design director (hierarchy, slop, heuristics), B = the deterministic detector + browser evidence. When the sub-agents finish, the main agent synthesizes (weave, never concatenate) the results from both for a balanced critique. Two blind opinions beat one confident guess.

I agree with the architecture. Review independence matters as much for agents as it does for human teams; the reviewer needs a perspective the maker didn’t already shape.

Bakaus’s second technique is “Force divergence · escape the cluster, don’t chase it with bans”:

Bans just move the model from one region of latent space into another. The escape is sideways, not a longer denylist.

Here are three techniques that produce higher divergence (cheapest but weakest first):

1. Shave the safe picks: make the model name its top 3 fonts, then discard all three. Out-rank yourself.
2. Generate ~50, a blind sub-agent keeps the 5 most distinct. (Lives in Radiant’s codebase, not Impeccable yet.)
3. Seed from outside the model: palette.mjs --from 8f2a starts in a region the model never picks on its own.

This is a better response to repetitive AI aesthetics than accumulating another denylist of fonts and visual effects. The intervention changes the candidate set instead of pleading for a better choice.

The third is “Give them memory · runs that compound instead of restarting”:

Most skill authors treat skills as stateless prompts, but there’s no rule that says a skill can’t have state. Keep in mind that skills can be bundled with scripts that can be run anywhere during the lifecycle of the skill!

Impeccable’s critique and polish commands use this technique quite effectively:

1. /critique writes a snapshot per target (score, P0/P1, markdown + frontmatter)
2. /polish reads the latest snapshot as its fix backlog

One non-obvious detail that makes this work across a team: the snapshot slug comes from the resolved file path, not from how you phrased the request. A teammate pointing at the same file inherits the same memory, and the score trend (24, then 28, then 32) survives across sessions.

This one is immediately practical: save the work on disk, then let the next command pick it up.

If you’re configuring agents for product and design work, start by cleaning up their context. Anthropic’s Thariq Shihipar offers several recommendations; three are especially useful here:

First, replace blanket prohibitions with an instruction that lets the model read the code around it:

In the new system prompt we say: Write code that reads like the surrounding code: match its comment density, naming, and idiom.

That trades a brittle universal rule for a concrete standard the model can inspect.

Second, move specialized guidance out of the always-on context and load it only when the task calls for it:

Since then, Claude Code has gotten very competent at using progressive disclosure- loading the right context at the right times. For example, we moved verification and code review into their own skills that Claude Code could selectively call.

For design and product agents, that leaves room for richer task-specific standards without crowding every session with irrelevant rules.

Finally, Shihipar on what belongs in CLAUDE.md:

Keep your CLAUDE.md lightweight and briefly describe what your repo is for, but spend most of the tokens on gotchas inside of the codebase. For example, you may organize your code to keep types in one monolithic file and nowhere else. Avoid stating ‘the obvious’ things Claude should know by looking at your file system or your repo.

Use progressive disclosure heavily, for example if you have several unique instructions on how to verify your work, create a verification skill and reference it from your CLAUDE.md.

Product designer and UX Planet editor-in-chief Nick Babich describes software development shifting from production to direction. The design version is familiar by now: as interface production gets cheaper, the work beyond the artifact is defining the right problem, directing agents, evaluating output, and owning the result. Babich traces the same shift in software:

Software development as manual code production is dying.

Software development as translating detailed tickets into predictable implementation is dying.

Software development as a protected technical craft that non-programmers cannot access is dying.

But software engineering is evolving into something broader:

Problem definition + architecture + agent orchestration + verification + product judgment + accountability

This changes the role of the developer.

The most valuable skill is no longer the ability to write code.

It is the ability to define the right problem, provide agents with the right context, evaluate their decisions, and verify that the final result actually works.

Software developers are becoming software creators.

I agree. Replace code with interface production and developer with designer, and Babich could be describing our profession. But there’s a problem both fields share: judgment is built by doing the low-stakes work AI now handles.

Junior developers were historically hired to complete simple implementation tasks such as:

• Build a basic interface;
• Write repetitive tests;
• Fix small bugs;

and these tasks allow them to learn from experienced colleagues and grow professionally.

But in 2026, these tasks are precisely the tasks coding agents handle best.

The loop engineering theme explained how to replace turn-by-turn prompting with a system that discovers work, assigns it, checks the result, and remembers what comes next. AI engineering writer and former Google engineering leader Addy Osmani scales that idea into a software factory and adds the governing constraint: the work can move only as fast as humans can review it.

A software factory is many harnessed loops running at once, fed by a queue of work and drained through a review gate into production, with humans owning the whole thing from above. It is not a bigger agent; it is an org chart made of loops.

Osmani follows that definition through the factory’s wiring diagram:

By and large, every box in this diagram is almost zero cost: generation, tests, scanning. They all run at scale for negligible cost. There is only one expensive box that proves stubbornly resistant to scaling, and that’s the review gate. That shiny amber box is “judgment”, and where the crux of the argument about whether we can make development faster and more frequent resides.

For Osmani, the review gate sets the pace. More generation only helps when verification scales with it; otherwise the factory manufactures a queue of code no one has the attention to understand. Imagine a conveyor belt of products being assembled together, only to pile up at the end, waiting for a poor human quality checker.

Osmani turns that constraint into architecture:

You might be thinking that all sounds unglamorous. You’re right. The safety net is made up of perfectly ordinary architectural practices we’ve always known about and mostly ignored: good types and method signatures so that mistakes are caught by the compiler instead of in production; test seams where we can pin behavior and make change observable; laying out the code so the next reader, human or model, knows where to find the thing they care about; keeping call stacks short and legible; keeping component boundaries well defined so a change doesn’t have a huge blast radius; and dependency injection so we can swap out one piece for another. None of it is new. We’ve always said we care about good architecture. But now that we’re using automated coding agents, that architecture is finally doing a second job as a cheap and hard-to-fake safety net against the mistakes the agent will make.

Put plainly, structure the work so mistakes are easy to spot and changing one thing doesn’t break everything else.

For designers, that means clear rules for each component, documented states, testable prototypes, and explicit review criteria. Build loops that can keep moving without you, but let them move only as far as those checks can prove the work is sound.

Kate Conger, writing in The New York Times, shows how Google’s AI Mode can include links to the open web while making them mostly irrelevant. The product gathers information from other sites, assembles an answer, and keeps the user inside Google. That goes beyond the earlier drop in publisher referrals linked to AI Overviews: Google is reconstructing the trip across the web inside its own interface.

Conger starts with Google co-founder Larry Page’s 2004 promise and the bargain that made Google powerful:

“We believe a well-functioning society should have abundant, free and unbiased access to high-quality information,” Mr. Page said.

Google fulfilled that responsibility by acting as a gateway to the internet. It answered people’s search queries with lists of hyperlinks, pushing users out to what is known as the “open web” — the millions of websites run by merchants, publishers, universities and others — for more information. In the ensuing decades, Google became one of the planet’s richest and most powerful companies by directing people to the vastness of the open web.

Now in the age of artificial intelligence, Google appears to be shrinking back from the open web — and may be imperiling it.

That enclosure is a product behavior, not a login requirement. Conger gives a simple example:

While someone might once have Googled a soccer player’s World Cup performance and clicked to a sports site or a social media thread for commentary, a bot now crawls the web for that information and returns the player’s statistics to the user, who stays on Google.

Google says it still sends billions of clicks and highlights links to the web. But those links now compete with an answer designed to remove the need for them. Conger ends with the contradiction:

In May, Vox Media, which owns The Verge and other publications, began selling some of its sites. Jim Bankoff, Vox Media’s chief executive, said the “decimation of search traffic” had influenced his decision to explore other ways of reaching readers, like a podcast network, and ultimately to sell about half of the company to James Murdoch. In June, The Verge and several other Vox Media websites were sold to Penske Media.

Google has often said it was “sending out more traffic and the web is bigger than ever,” Mr. Patel said. “And then right next to that is a bunch of publishers whose businesses are getting destroyed.”

I’ve started using AI this way in a lot of my daily work. In my day job, after diving into a problem, I give Claude the right context and iterate with it to get to a problem brief. In my freelance work, I set the parameters—the concept, style, or general functionality—then iterate with the AI.

AI product manager and builder Karo Zieminski, writing in Product with Attitude, calls this “AI-assisted craft”:

AI-assisted craft means the human sets the intention and the standard for the work, then directs how it gets made. AI gets a defined supporting role. Supporting, as in: it does not get to make the decisions. The practice applies across knowledge work and digital creation, from writing and research to coding and design.

Zieminski separates assistance from direction:

AI-assisted. The human is the primary maker. The choices, mistakes, revisions, and final form are theirs. AI is one of the tools they use.

AI-directed. The model produces the work; the human directs it. That direction must be consequential enough to shape the result. One prompt followed by a shrug is generation with supervision theatre.

Both require the human to make consequential choices. In my workflows, that happens throughout the iteration, not only when I write the first prompt.

Zieminski’s bounded-task rule makes that concrete:

“Improve this” is not a bounded task.

Give the model a job with sharp edges: do this, not that.

Research for me, BUT bring me facts, not conclusions. Challenge my assumptions, BUT do that through Socratic questions so I have to do the thinking. Explain this code block, BUT test whether I understood it. Suggest design fixes BUT don’t bleach my personality out of it. Whatever it is, leave space for my judgment.

I agree, with one small addition: setting the boundary starts the work. AI can’t answer the question at the other end for me: Would another change improve it, or is it time to stop asking?

Companies may be cutting the very workers AI helps most.

A Stanford Institute for Economic Policy Research policy brief by Neale Mahoney, Erika McEntarfer, and Karsen Wahal finds no economy-wide “AI jobs apocalypse.” But its early evidence creates a possible paradox: employment among less-experienced workers has declined in AI-exposed roles, even as experiments show that AI often gives them the largest productivity boost.

Recent graduates are facing the most challenging job market in years, with unemployment rates for new grads reaching 5.6 percent in early 2026, up 1.6 percentage points from three years earlier. This rise has fueled concerns that AI is replacing many of the jobs recent graduates once sought. Junior roles often involve routine research, analysis, and writing tasks that can now largely be done with AI. Consistent with this intuition is empirical evidence that AI may be dampening demand for new hires.

In a widely discussed paper, Brynjolfsson, Chandar, and Chen report a notable decline in employment among early-career workers in AI-exposed occupations, notably software developers and customer service representatives, since ChatGPT’s launch in 2022. As shown in Figure 2, by contrast, employment among older workers in those same occupations remained relatively stable or continued to grow. The authors liken these young workers to “canaries in the coal mine,” the first to experience labor market disruption from AI. Other researchers have since identified similar negative effects on the hiring of young AI-exposed workers in the U.S. and the U.K., beginning in 2022.

The authors are careful not to pin the entire decline on AI. The Federal Reserve’s rate hikes, the end of pandemic staffing surges, and weaker on-the-job learning in remote roles all muddy the timeline. But the hiring decline itself is real, and younger workers in AI-exposed jobs are taking the hit.

Design’s vanishing bottom rung looks even more precarious against this evidence. The brief does not study designers specifically or establish that AI caused the decline. But if employers are closing junior roles in anticipation of AI, that is a business decision, not a technical inevitability. And the productivity findings make that logic even stranger:

In experimental settings, generative AI tools — such as chatbots and coding tools — have often been found to disproportionately improve the performance of less experienced and poorer performing workers. In one such study, researchers analyzed the impact of a generative AI assistant on customer support agents in a large call center. The assistant increased overall productivity by 15 percent, with gains highly concentrated among novice and less-skilled workers, who saw a 30 percent improvement in the number of issues resolved per hour. There was no performance improvement among highly skilled customer service agents, whose response quality fell slightly.

Other studies also show that AI tools generally speed up task completion, though the effects vary by task, context, and skill level. Figure 3 summarizes research findings on the impact of AI tools on speed across a variety of tasks. In software development, the use of GitHub Copilot — an AI tool that suggests code and functions — allowed tasks to be completed 56 percent faster, with gains concentrated among less-experienced programmers. More modest impacts on software development were found in a separate paper, with effects ranging from 10 percent to 30 percent, depending on the firm where it was deployed.

If companies stop hiring the people who benefit most from these tools, who exactly do they expect to become tomorrow’s senior talent?

Experience is usually treated as an advantage, as exemplified by Google product leader Jules Walter defining what product sense is in Lenny’s Newsletter:

Product sense is the skill of consistently being able to craft products (or make changes to existing products) that have the intended impact on their users. Product sense relies on (1) empathy to discover meaningful user needs and (2) creativity to come up with solutions that effectively address those needs.

Quoting Walter, Tanner Kohler, a researcher at Nielsen Norman Group, argues that it can become a trap when the current problem only looks familiar. He contrasts his definition of product sense with Walter’s:

Product sense is the ability to recognize when current problems match past successes or failures and reliably estimate how similar solutions will affect the desired outcomes.

[…]

This definition improves on Walter’s because it turns product sense from a loose combination of empathy and creativity into a measurable decision-making skill. It specifies the mechanism behind strong product judgment: recognizing when a current problem resembles past successes or failures, predicting likely outcomes, and knowing when those comparisons are reliable. That makes product sense easier to recognize, practice, and improve.

Pattern recognition gets most of the credit when we talk about senior judgment. For designers, calibration means knowing when a pattern that worked before no longer fits the problem in front of you.

Kohler then limits where experience can be trusted:

Our definition requires people with strong product sense to know both when an experience-based pattern is likely to work and when it is not. That judgment is the “sense.” It is not magical, does not come automatically with time, and remains limited to a person’s domain of expertise.

Consider a fire chief experienced with small building fires advising a crew during a skyscraper fire, a NICU nurse caring for an adult patient, or a chess grandmaster playing checkers. Do the cues they learned in one domain still apply?

Daniel Kahneman and Gary Klein point out that any new decision-making environment needs to provide sufficient familiar clues for an expert to accurately match the patterns they’ve learned to the current situation.

Kohler warns that AI can also interrupt the decision–implementation–measurement–reflection loop that creates those patterns:

Buzzwords come and go. There’s nothing wrong with the term “product sense.” The problem is believing that, with little data, an ever increasing velocity, and more work and decision making outsourced to AI, people can develop a “sense” for what to do without rigorous thinking.

Intuition comes with time and repeated exposure to real product decisions and results. AI may rob you of the chance to develop product sense if you aren’t careful. Stay in the ring, own your decisions, and face the results. This is what will make you valuable for years to come.

Most software companies organize product work around squads. Users don’t care. Their workflows cut across the boundaries we draw between teams, so a local decision about a table, filter, or bulk action can become a product-wide inconsistency.

In my conversation with Denis Cristea on UX Spotlight by Userlytics, I described how this happens:

We have this notion in modern software companies around squads and how a squad will own a particular surface area in a product. You’ve got your product manager, product designer, engineering lead, and then a bunch of engineers. So that’s your classic triad and team makeup. Theoretically everyone owns their roadmaps, talks to customers, and decides what to build.

Users don’t just work in one module. Users often work in multiple modules. So they’re already crossing the org chart, if you will. […] When thinking about the entire user experience, you already have to coordinate across different teams.

Meanwhile, you’ve got another module, another group, another team who wants to work on something similar, but they’re not talking to each other. When that happens, that’s when you get the inconsistent user experience. They might solve the same interaction differently.

A design system standardizes the components each squad uses. Weekly critique lets designers see the decisions being made across those squads before separate implementations harden.

I used the example of bulk actions at BuildOps:

The other thing that we’ve been doing a lot on my team at BuildOps, the design team, is the weekly design crit. That’s a way for us to keep the connective tissue together and ensure that the experience across the different modules stays as consistent as we can.

Going back to the bulk actions example, if one team needs it and a designer builds that experience, other designers will see it and say, “Okay, that will actually help my area too. After you design it and create the components, let me take that and put it in my area too, and argue with my product manager to prioritize that work.”

Critique coordinates the product while the squads remain autonomous. It gives teams a shared view of unfinished decisions and a place to resolve them before users have to deal with the seams.

Product managers can use the same ritual:

I would recommend that product managers think about implementing something that designers do, which is critiques. I don’t think product managers have this ritual of sharing what they’re working on and how they’re thinking through problems.

When you build a culture of sharing and oversharing, and also wanting to make everyone else’s work better by giving them good constructive feedback, that’s when the whole product is going to get lifted up.

Quotes lightly edited for clarity.

When I first saw Coca-Cola’s new identity video, the “More iconic than ever” card stopped me. The red-and-white serif type immediately reminded me of Marlboro. I know the fonts are different. I also know I’m not alone in seeing it.

That collision is frustrating because the system itself is excellent. Brand New writer and UnderConsideration co-founder Armin Vit:

Overall, a lot of work and thought went into this and it shows. The identity elements, as ubiquitous as they have been for decades, feel as if they’ve been given a new lease on life and have found an exciting way of coming together to infuse Coca-Cola with a breath of fresh air. The brand could have easily rested on its laurels and 140-year momentum but it’s quite commendable they have challenged themselves to reinvent without actually reinventing anything but rather by remodulating the existing equity of all of its elements in exciting new ways.

Vit’s typography assessment is just as positive:

Speaking of the new typography, this is probably the best effort yet between Brody Associates and Coca-Cola, which has included a rather tame sans serif and a more expressive serif, which seems to be the starting point for this newest family and it’s excellent. Thick serifs, tall x-height, and short ascenders and descenders add up to an elegant yet playful type family that is a perfect complement and contrast to the Spencerian script, not to mention a nice nod to the first Coke shorthand logo.

Still, Remy Tumin, writing for The New York Times (gift link), says other viewers made the same comparison. One designer she interviewed explains why:

“The big part of the Marlboro comparison comes down to the most simple elements, which are type and color,” said Elizabeth Goodspeed, a graphic designer and adjunct professor at the Rhode Island School of Design. But the fonts are not the same: Coke is using a custom serif design called Better With, and Marlboro’s font is Neo Contact.

This is professional-level work. But brand perception isn’t a type specimen: once a prominent execution makes people think of cigarettes, proving the fonts are different doesn’t make the association disappear.

Yennie Jun, writing for Art Fish Intelligence, asks which parts of thinking we surrender along with the task. Her example shows the difference between asking AI to answer a question and asking it to test thinking we’ve already begun:

I suggested (with only a little bit of initial resistance) that we pause and think about why this might be. I suggested a few theories. Perhaps it was Portugal’s relative homogeneity and religiousness, compared to the US’s diversity of immigrants. Perhaps Portugal clung on to so-called “Age of Exploration” as one of the most prominent chapters in its national story. We wondered, postulated, made wild guesses, backtracked, connected our ideas, disagreed, and remembered historical details we learned in high school many years ago. We drew on our collective memories, knowledge, understanding of the world, and critical thinking skills. We knew we were speculating, and some of our theories were probably wrong; that was part of the exercise.

Eventually, we asked the same question to AI. Its response corroborated many of our theories and supplied several explanations we had missed. It also omitted a few possibilities we still found plausible. We had begun with a question, generated hypotheses, and only then used AI to test and extend our thinking. I relished the exercise.

The backtracking is the point. A finished answer can save time, but repeatedly skipping the work of forming and testing a hypothesis also skips the practice that builds judgment. For designers, that’s the work we should keep, even as it accelerates production.

We still need to use trial and error to learn what to ask or try next. Otherwise, faster production leaves us less able to tell whether what we made is any good.

Jun turns from productivity to autonomy:

Am I any different from the Microphone Man? Perhaps what differentiates me is that I still collected and curated the data, formulated the questions I wanted answered, and evaluated the end results? Or that the data was my own, instead of recording other people’s conversations? There will always have to be some balance between automating menial tasks to free up time for rewarding endeavors, and doing the work yourself as a learning experience.

Jenny, another character in Ken Liu’s story, aims to counterpoint the main character’s over-reliance on his AI assistant. She exclaims, “Tilly doesn’t just tell you what you want! She tells you what to think. Do you even know what you really want anymore?” Our autonomy depends, at least in part, on continuing to participate in forming our own desires. But when we offload thinking about what we want (What music should I listen to? What movies should I watch? What food should I eat? What shoes should I wear?), who do we become?

What are we automating? Human work or human agency? Human tasks or human thinking?

Designers still have to decide what deserves to exist before asking AI to make it.

Om Prakash, writing for UX Collective, argues that chat should handle ambiguous intent rather than replace graphical interfaces:

This is a distinction Erika Hall draws precisely in Conversational Design (A Book Apart, 2018) — arguably the sharpest book written on this subject. Hall argues that conversation is the right design choice only when the system needs to negotiate meaning with the user. When the user already knows what they want — “add to cart,” “filter by price,” “submit the form” — conversation is overhead. Structure is faster, more accurate, and less exhausting. Conversation earns its place only when intent is genuinely ambiguous: when the user is exploring, when their goal is fuzzy, when they need the system to meet them partway.

This framework changes how you evaluate chat implementations in the wild. The products that figured it out early didn’t go all-in on chat. They built hybrid interfaces , structured UI for known, predictable tasks; conversational AI for open-ended, exploratory ones.

For designers, the practical choice comes before any screen or prompt: how clear is the user’s intent?

Choosing the interaction mode becomes more consequential when software can act. A form submission can usually be corrected; an agent may send an email or book a flight before the user realizes it misunderstood. Prakash shifts from intent to oversight:

The UX problem this creates is the most interesting one in our field right now: how do you design an interface for an agent that doesn’t need an interface to do its job, but whose users absolutely need one to trust it?

Ben Shneiderman, in Human-Centered AI (MIT Press, 2022), has been asking a version of this question for years. He argues that the dominant framing of AI as an autonomous agent replacing human judgment is both technically premature and ethically dangerous — and proposes instead a framework of high human control combined with high automation. Not one at the expense of the other. The goal is not to minimize human involvement; it’s to make human oversight legible, accessible, and non-burdensome. Shneiderman’s model is the right north star for agentic UX: not autonomy versus control, but autonomy with control — designed into the system from the start.

This is the transparency paradox of agentic design. An agent that operates silently is efficient and terrifying. An agent that narrates every action is trustworthy and exhausting. The design challenge is finding the right level of visibility — enough that users feel in control, not so much that they’re overwhelmed by a stream of system-generated activity logs.

Jakob Nielsen’s AI-generated illustrations do his work no favors. His visual taste is, to put it kindly, not mine. But Jakob Nielsen has done something few technology forecasters ever do: he pulled out papers from 1993 and 1996, scored 23 predictions against computing in 2026, and published the misses alongside the hits.

The 71% headline is Nielsen’s own grade, and he acknowledges the obvious conflict:

Two clarifications. First, timing gets no separate penalty because the delay affects nearly every row. Neither paper promised a full system within a decade; Noncommand explicitly said such a system was unlikely “within the next ten years, which is about as far as one can predict in the computer field with a minimum of credibility.” The vision nonetheless took 30 years to become a widely shipped product pattern, a delay I return to in the lessons.

Second, I’m grading my own homework, which is an obvious conflict of interest. I’ve tried to score against what shipped and stuck, not against what demos well, and I show every score so you can regrade me.

So I wouldn’t get hung up on whether 71% is exactly right. Nielsen and his late co-author, computer scientist Don Gentner, still saw an intent-driven interface decades before machine learning made one practical. Some of the details are uncanny; others reveal how a sound principle can survive the failure of its original mechanism.

Nielsen on one of those switcheroos:

In 1993, I described moving an on-screen object “by selecting it by looking at it and then pressing a selection button (to prevent accidental selection).” In February 2024, Apple shipped Vision Pro with the same core selection pattern: look at a target, then pinch to commit. The prediction reappeared three decades later with its confirmation step intact. Of course, the Vision Pro remains a niche product, which is why the bandwidth and interaction-stream rows score in the middle of the scale: the high-bandwidth immersive future arrived, but as a sideshow. The main stage went to the lowest-bandwidth input device imaginable: an empty text field.

The physical channel narrowed while the semantic channel widened. Our mistake was measuring the interface by how much raw data crossed it rather than by how much work each user token could trigger. The better metric for AI is intent leverage: useful output divided by the effort required to specify the goal.

And this 1996 sentence comes remarkably close to describing the interface designers should be building beyond the prompt box:

We assumed users already knew what they wanted and just needed a better way to say it. Conversational AI revealed that human intent is rarely a pre-formed cognitive object just waiting to be translated; rather, intent is fluid and often discovers itself through the act of conversation. Current AI user interfaces do little to help users figure out their intent, but even primitive AI UX already supports some degree of iterative co-articulation.

One sentence from 1996 aged better than everything else Don and I wrote: “Real expressive power comes from the combination of language, examples, and pointing.” That’s a working definition of multimodal prompting: type your intent, paste an example of what you want, and point by uploading an image or selecting a region. If I could grade a single sentence at 100%, this is the one.

Language is best for leaping across a large solution space: “make this calmer,” “compare these contracts,” or “plan a week in Kyoto.” Pointing is best for local correction: this paragraph, that number, the face in the upper-right corner. Examples communicate qualities users can’t easily name. The winning AI interface will therefore let language propose, examples constrain, and pointing repair.

Nielsen and Gentner’s prediction worked because the underlying idea was stronger than the technologies they had available. They got the vehicle and timing wrong. They also expected expert users to benefit most. Yet language, examples, and pointing still sound like a better creative interface than an empty text field.

Artist Katya Ross, in a talk published by CreativeMornings, the global creative community and lecture series, argues that content abundance has made intentional curation the problem:

We don’t have a content problem. We have a curation problem as a culture, as people in this overloaded culture. We don’t want more content. We want more meaningful content. […] The problem with trying to seek out meaningful content: your brain wants you to stay alive. Your brain curates according to survival, not necessarily meaning. And social media algorithms, which is a lot of where we get all of the content that we view, curate according to ad revenue. They curate according to what you pay attention to, whether you like something or not, whether you agree with it or not. It just wants your ad revenue, and it wants you scrolling.

Ross means something more specific by curation than choosing the best items from a pile. For her, it is the act of constructing relationships that create meaning:

To define curation for the sake of this talk, I would say that curation is constructing and carefully considering the relationships that make meaning possible. Curation is, in other words, the fundamental mechanism through which we can create and communicate meaning. Now, it’s just a mechanism. There’s no guarantee that your curation is going to be any good.

That shifts originality away from producing something with no precedent. The contribution is the relationship a creator sees among inherited ideas, materials, and experiences:

We are in relationship with reality. We are not truly inventing anything. We are working with what’s already there, whether that’s materials or ideas. Every idea has a lineage. Even if it is an original idea, everything that’s gone into your mind has laid the groundwork for this idea. The ideas are related to one another. Every work that you create exists in this messy, beautiful, complicated web of work that has come before, work that sits beside, work that will come after.

That is a more useful standard for originality than novelty. The materials can be familiar and the work can still be original when the relationship it reveals carries the creator’s particular way of seeing.

Ben Callahan on what a design system can and can’t guarantee:

A design system can only raise the quality floor. It sets the baseline below which nothing should ship. An accessible-by-default button, a holistic and thoughtful approach to spacing, a template that starts a consuming team ten steps ahead.

But a design system alone can’t raise the quality ceiling. That’s not something you can do by delivering assets. The worst product teams can make awful experiences with the best design systems. That’s because the quality ceiling is set by the choices product teams make with what you give them. It’s their restraint, it’s where they push, and it’s knowing when to deviate from the standard because the standard isn’t serving the end user.

Callahan’s title invokes AI, though the essay only touches it indirectly. The connection follows from his distinction: faster generation and stronger defaults can produce more acceptable work, but neither can decide when the standard is failing the user. That decision still requires careful judgment.

Callahan on the loop:

And, of course, this loop just continues to run. Over time, the quality floor and the quality ceiling are raised.

The most important step here isn’t the shipping of a new component. It’s the time in conversation that results in alignment on a definition of quality.

Your system sets the floor. The way your system is used sets the ceiling. If you’ve poured everything into the first and bowed out of the second, it’s time to step back into ring.

Modernism’s typographic principles have survived so long that clarity and legibility can feel less like choices than natural law. New New Typography asks what changes when designers treat those principles as products of their time rather than permanent rules.

Paul Moore, writing for It’s Nice That:

Are we stuck with the established typographic principles of the 20th century? This is what German design studio Matter Of is asking in its design book New New Typography (published by Sorry Press). The title is in direct reference to the proclamation of Jan Tschichold’s original “new typography” in Central Europe 100 years ago. Now Matter Of (and designer Wiegand von Hartmann) are at the spearhead of an even newer typographic revolution: the ‘new new,’ searching to unsettle established paradigms, expand vocabularies and innovate type design. That is, until it’s time for the ‘new new new’, but let’s not worry about that right now.

The book makes that challenge through form, not just argument. It switches among six sans-serif typefaces and marks its black-and-white pages with aggressive cyan, turning the act of reading into a test of what counts as coherent:

New New Typography makes itself known immediately with its minimalist aesthetic, using black-and-white print with a searing cerulean cutting through the page in disruptive squiggles or sometimes blocks of highlighted text (a conscious effort to make the book look like a textbook blasted with felt-tip markers). The book is designed using six different sans-serif typefaces that alternate across chapters, raising questions in ironic and subtle ways, such as ‘when is a typeface considered new or different?’, playfully reflecting on the evolution of Helvetica, Helvetica Neue, Helvetica Now. To find ways to bring proliferating typographies into relation, the book sketches engagement between the typeface’s different dependencies, all with a tongue planted firmly in cheek.

That makes the book less a replacement doctrine than a device for questioning doctrine:

Described as a messy and unstable anti-manual for typography, 243 figures and six theoretical proposals present an overview of the impossibility of an overview on typography – it’s adventurously speculative, blending high design theory with a modern irony and cheekiness. What if the modern typographer isn’t just a typographer, but an active negotiator of political systems? Nevertheless, it isn’t a book about delivering an answer. Nowadays, just daring to imagine the future is enough.

But refusing a single answer does not mean refusing standards altogether. If typography helps negotiate political systems, its experiments still need to account for who can read them and what power they reinforce. Imagination opens the field; judgment decides what deserves to remain.

Patrick Neeman, writing for UX Collective, compares today’s AI interfaces to the browser wars:

[Jeffrey] Zeldman did not invent the specifications, he did something harder: He convinced an entire industry that shared conventions were worth fighting for, and he won. Zeldman changed the world with a stance, not a specification and we should thank him for it.

We are living through that moment again, this time for the interfaces we wrap around models, the skills we scaffold on top of them and representations they mean.

The browsers have new names: ChatGPT, Claude, Gemini, and Copilot each handle the same task their own way, with their own conventions for parsing content, showing reasoning, citing a source, and asking permission before they act.

The connection to design systems is structural. Browser standards gave different products a shared foundation without forcing them to look identical. Neeman doesn’t claim that the conventions for AI interfaces are settled; he proposes design systems as the way practitioners can develop and share them:

The core move was to pull structure, presentation, and behavior into distinct layers so each could change without breaking the others. That one idea outlived every specific technology it was built on.

It is why a design system works at all.

When Brad Frost introduced atomic design, he was extending the same instinct: stop shipping pages, start composing interfaces from small, shared, recombinable parts. Design systems are the standards movement’s direct descendant, and they are the closest thing we have to a working model for AI interface conventions.

That working model is already appearing in the Markdown files agents use as project-level contracts:

Agents increasingly take their instructions from plain text files that sit beside the work — AGENTS.md for how an agent should behave in a project, SKILL.md for what a capability can do, README.md for the context around both.

This is the new semantic layer. It is markup again, written in Markdown and read by a model instead of a browser.

[…]

A design.md that carries your design system’s patterns, tokens, and rules into every agent that touches the product. An accessibility.md that states the non-negotiables in language a model can follow. A content.md that fixes voice, terminology, and the content model.

Neeman also points to a broader protocol stack taking shape:

You are not waiting for this to begin. It has begun. A partial map of the standards taking shape right now:

• Model Context Protocol — a shared way for a model to reach tools, data, and context, already adopted across rival platforms and now stewarded by a neutral foundation.
• A2UI — a declarative protocol for agents to describe interfaces that render natively across web, mobile, and desktop, keeping what the interface is separate from how each client draws it.
• Agent2Agent — an open protocol for agents to discover one another and collaborate across frameworks and vendors, launched by Google and handed to the Linux Foundation.
• The W3C AI Agent Protocol Community Group — a grassroots group drafting open rules for a trustworthy web of agents.
• Agent identity work — cross-body efforts, at the W3C and beyond, to verify who an agent is and what it is allowed to do before it acts.

None of these is finished, and that is the opening. The conventions are still soft enough to shape, which is exactly where Zeldman’s coalition made its difference.

Pick one metric on your team’s dashboard. What decision would change if it moved?

Ant Murphy offers two questions for finding out:

Two of my favourite questions to ask about any product metric are:

1. What are you trying to learn?

2. What change will you make as a result?

There are thousands of things you can measure, but measuring for measurement’s sake isn’t helpful. It needs to drive decisions.

The second question puts a team on the hook before the data arrives. It forces the decision rule into the open, when there’s less temptation to rationalize whatever the chart happens to show.

Murphy also argues that difficulty assembling a metric can be evidence that the team has stopped settling for whatever its analytics tool already exposes:

And that’s the trap that Ridgway was describing all those years ago and it’s still relevant today.

So I see friction as a good sign - it means the metric is:

• Unique: specific to your product and your problem, not pulled off the analytics shelf
• Meaningful: tied to the behaviour change you actually care about
• And thought through: you’ve actually unpacked what you’re trying to learn

So it’s worth pushing through the friction. I’ll take a meaningful proxy, or a smaller sample of something high-quality, over a generic metric every time.

Kai Wong asked 32 design leaders what they do when companies mistake faster production for faster design. He begins with a plumber:

Imagine a plumber walks into your house, looks at the pipes for a few minutes, tightens one valve, and hands you a bill for $300. Your first reaction might be, “Anybody could have turned that valve.”

Wong borrows a distinction from neuroscientist and Tiny Experiments author Anne-Laure Le Cunff: “the ancient Greeks had two words for time, not one.”

The first is chronos: time as quantity. The number of hours in a day, the number of weeks in a year. This is the time your projects are based on.

The second is kairos: time as quality. Not how much, but how good. Le Cunff frames it not just as better quality time: it’s having the time to recognize a pattern from everything you’ve seen before and know it’s the right time to act.

[…]

Design runs on Kairos. AI might have made things faster, but businesses don’t need 500 screens by lunchtime.

They need the right solution to their problem. And that comes from the quality of thinking that happens along the way.

Wong closes:

When AI is your competition, the temptation is to compete on its terms. Faster. Cheaper. More. You’ll lose that race. And you’ll produce worse work while you lose it.

Compete on the thing AI doesn’t have. Judgment.

Generation is chronos, and chronos is cheap now. Judgment is kairos, and kairos is the whole job. Protect it. Make it visible. When someone asks you to cut the timeline in half, be ready to explain clearly what they’d actually be cutting.

Lola Famulegun, writing for Nielsen Norman Group, separates the UX metrics that describe design performance from the business metrics executives use to judge an investment:

Upstream metrics tell you how the design performed. Examples include task success rates, error rates, SUS scores.

Downstream metrics capture what changed in the business as a result. Examples include support contact volume, conversion rates, and churn.

Downstream metrics tell you what the work was worth. You don’t need to abandon the metrics you already collect, but you do need to build a bridge from them to the ones leadership tracks. The table below maps common upstream metrics to the business priorities they most directly connect to, with a suggested framing for each.

Famulegun also points out that the translation depends on access to data outside the UX team. I recall that my team had to fight with my company’s revenue operations team to get access to Salesforce data so we could make prioritization decisions with ARR as an input.

Famulegun:

The data you need already exists inside your organization. Partner with finance, product analytics, customer support, or marketing to understand what they track and to get access to before-and-after data for flows you’ve redesigned. Even directional data is persuasive when it’s honest: “Contacts about [feature] dropped 30% in the quarter following the navigation change.”

A practical note: this translation only works if you have access to downstream data. If your team isn’t currently connected to product analytics, customer support, or finance reporting, that’s the first conversation to have.

The goal isn’t to overstate what UX delivers. It’s to surface the connection that already exists between the work your team does and the numbers the business is tracking.

Laura Summers, writing for the Pydantic blog, describes the strange math of coding agents: the work can run in parallel, but our attention can’t.

Marcelo, another Pydantic colleague, when asked about his Claude Code session freezing said: “just open 5 claude sessions. You’ll never notice because you’re busy giving feedback to the others.” He was joking. I think. But it captures something true about the current moment. The parallelism is exhilarating and kind of feral. The number of things you can start has dramatically increased. The number of things you can thoughtfully finish hasn’t changed at all, because that part still requires the one resource we can’t parallelise: your brain.

The design version is easy to recognize: an agent can generate dozens of screens and states while one brain still has to judge the product intent and every edge case. You may spend less time drawing the interface, but every state still demands a decision.

Summers calls the emotional cost “the human reward function problem”:

Here’s a term for what I think is happening: the human reward function problem. In machine learning, a reward function tells an agent what good looks like. Writing code by hand was never easy, but it was full of small rewards. Solving a problem in your head. Understanding a gnarly bit of logic. Watching the code compile. The feeling of control. LLM-assisted programming has automated much of the work that generated those dopamine hits and replaced it with the cognitive load of review and supervision. The satisfying part shrank. The exhausting part grew. And there are no new rewards to fill the gap.

If you’re feeling like your work is simultaneously more productive and less satisfying, you’re not broken. The feedback loop is broken. And I think we need to start treating that as an engineering problem in its own right, not a personal failure.