Summary: Agent-ready web design lifts AI task success | Shoppers now pick AI assistants over brand websites, 41% to 38% | Learn from reality: build and iterate | AI getting better at business strategy, but still not good enough to run your company | AI raised the floor but lowered the ceiling in children’s storytelling | Infinite canvas as a UI space for organizing and collaborating on unstructured information | My Hero: Scott McCloud, comic book artist and theorist | AI animates classic paintings to retell Homer | The goal-gradient effect boosts users’ motivation as they near completion of a process | Users spend ever-more money on AI subscriptions | Used right, AI increased learning in Africa

UX Roundup for July 31, 2026 (GPT Image 2)

Agent-Ready Web Design Lifts AI Task Success from 49% to 89%

In a controlled experiment, AI browser agents completed 89% of e-commerce tasks on a website redesigned for machine consumption, compared with 49% on the identical human-oriented site, while needing 30% fewer steps. Your website now serves two species of users, and the second species can’t see your pretty pixels.

Websites must now be designed to serve two species of visitors: humans and AI agents. (Muse Image)

Your Newest Customers Are Robots

AI agents increasingly browse, compare, and buy on their humans’ behalf, a shift I analyzed last year in “Hello AI Agents.” A new paper by Said Elnaffar (independent researcher in Canada) and Farzad Rashidi (Université Paris Cité), “Designing Agent-Ready Websites for AI Web Agents” (accepted at the ICEME 2026 conference), supplies early numbers on what it takes to serve these new customers.

Robots are shopping on your website. If you let them. If you want those sales. (Muse Image)

The authors built two versions of one small online store with identical products, prices, inventory, and checkout flow. The baseline was a conventional human-oriented site. The agent-ready variant added machine-friendly plumbing: product data exposed as JSON-LD, semantic labels and stable identifiers on interactive controls, explicit evidence such as reviews and certifications, and timestamps revealing data freshness. Three browser agents (GPT-4.1, Gemini 2.5 Flash, and Grok 4 Fast) then attempted 5 shopping tasks on each variant, 10 runs per task per model, for 300 runs in total.

Semantics Is the New Aesthetics

The agent-ready design won across every model and every task:

The biggest jumps came in data extraction and product comparison, both up a whopping 77 percentage points. Why did partial outcomes collapse from 43 to 3? Because baseline agents often found the right product but flubbed the details, whereas clean, labeled facts let them finish the job. Efficiency improved too: steps dropped 30%, and token consumption fell 19–40%, so agent-ready sites are cheaper for AI companies to shop at. I predict agent platforms will eventually favor low-parse-cost websites, much as Google rewards fast pages. Tokens are expensive these days. (Actually, the price per individual token is dropping like a stone, but the new agentic models eat so many more tokens that token budgets are exploding.)

I have always said that if websites are too difficult to use, then users leave. That will be just as true for AI agents as it always was for human visitors. For humans, the competition was a click away. In the case of AI agents, they’re already visiting 20 competing websites, having spawned parallel subagents. (Muse Image)

Savor the irony: the winning ingredients (semantic HTML, explicit element labels) are accessibility 101. Accessibility advocates preached this markup hygiene for 25 years to modest effect. Now that the audience is robots with wallets, businesses will finally comply.

Much of the advice for selling to AI agents echoes what we’ve always recommended for the sake of accessibility for disabled users. The difference is that agents will probably account for 100x more business, so companies are now finally motivated to listen. (GPT Image 2)

Strong Effect, Small Experiment

Of course, caveats apply. The authors built both website variants themselves, so the baseline may be a conveniently weak patsy. The test covered one prototype store and three mid-market AI models, with no ablation study to reveal which features earned the 40 points, and the gains on the hardest multi-constraint task missed statistical significance. Thus, treat the exact numbers as provisional. But the direction matches everything we know about how web agents fail: they misread cluttered pages and misfire on ambiguous controls. My best guess is that real-world gains will be smaller, yet still worth the engineering week these upgrades require. A confused agent doesn’t complain; it buys from your competitor.

8 Guidelines for Agent-Ready Websites

1. Publish structured data. Expose products, prices, and stock as JSON-LD or Schema.org markup instead of burying the facts inside JavaScript.

2. Write semantic HTML. Give buttons, forms, and links explicit labels, roles, and stable identifiers so an agent can tell “Add to Cart” from “Add to Wishlist.”

3. State each page’s purpose in plain text. Headings should announce what the page offers and what actions it supports, because agents lean on text far more than on layout.

4. Label actions unambiguously. Visible, descriptive button text beats icon-only controls, for agents and for your human users alike.

5. Provide verifiable evidence. Reviews, certifications, and cited sources let agents separate marketing fluff from checkable fact when recommending a purchase.

6. Timestamp volatile information. Prices, inventory, and policies need explicit freshness dates so agents don’t act on stale data.

7. Keep human and agent views identical. Same prices, same stock. Serving bots different data will destroy trust the moment a user double-checks the agent’s work.

Product specifications and prices must be identical, whether your site is visited by a human or an AI. (GPT Image 2)

One difference between designing for AI and humans is that AI can ingest and understand almost any level of detail, so it prefers extensive information up front. In contrast, users get overwhelmed and prefer to only be exposed to the most salient information initially, with secondary information deferred through progressive disclosure. The same information should ultimately be available to both types of users, but presented differently. (GPT Image 2)

8. Test with agents, not just humans. Run a browser agent through your top 5 tasks every quarter and log where it stumbles. Watch agents, not demos.

We should redefine our understanding of “user testing,” now that users are of two different species: humans and robots. Testing with human users should continue to follow usability testing protocols, as I explained in a series of comic strips, but we need to discover the best way to test with AI agents. (GPT Images 2)

Shoppers Now Pick AI Assistants Over Brand Websites, 41% to 38%

Propeller Insights surveyed 4,040 U.S. and U.K. adults for commerce vendor Bloomreach. 75% have used AI tools such as ChatGPT, Claude, or Gemini for shopping or purchase decisions, and 41% would now choose AI-assisted shopping over going directly to brand websites (38%). That’s a reversal from 2025, when 59% preferred brand sites. An 18-point swing in one year on the same question is too large to wave away.

AI shopping is starting to leave company websites in the dust. Brand sites are not quite abandoned by human users yet, but the trend is strong. (Muse Image)

80% say AI shopping met or exceeded expectations (which is, of course, why they prefer AI); 61% report more confidence in their purchase decisions; 38% say they spend more overall. Top uses of AI shopping agents: comparing features or prices (48%), hunting deals (46%), and finding product ideas (41%). And 56% plan to use AI shopping tools even more over the next 12 months. (Caveat: that’s stated intent, not actual behavior, but it would continue the trend from last year.)

Extremely strong user satisfaction with AI shopping agents. One reason may be that brand websites still mostly suck, which makes it easy for the AI user experience to shine by comparison. (Muse Image)

Product discovery is migrating from your website to an AI intermediary, and every UX investment in browse-and-filter journeys serves a shrinking channel. The design priority will become catering to agents, as discussed in my previous news item: structured product data, machine-readable comparison attributes, and honest pricing, because increasingly the AI reads your page, not the shopper.

Ship, Learn, Iterate

Build small. Learn fast. Keep improving. (GPT Image 2)

The whole secret of UX, in 3 words. Grand launches are gambles; iteration is compound interest. In my phone-company case studies, usability improved a median of 38% per design iteration, so 3 rounds more than double quality. Don’t wait for perfection (it never ships). Snap one brick in place, test it with 5 users, fix what wobbles, and stack the next. Big-bang redesigns topple. Small bricks build cathedrals. (A benefit of growing up in Denmark is that I learned these lessons with my LEGO bricks.)

AI’s Business Strategy Skills Improving

Can AI models plan your business strategy? Not really. For now, better to let the human founder (or a hired CEO, if the founder is no longer available) set the strategy. At least according to a recent analysis of leading AI models’ ability to solve business case studies.

Ajay Patel and colleagues from the Wharton School and other institutions built a new benchmark called BusinessCaseBench with 615 questions from 238 business school cases spanning 18 disciplines, from finance to negotiation. AI answers were graded against rubrics distilled from the instructors’ own solutions.

Definition: A business case is an expert-written narrative, usually authored by a professor, that drops students into a messy decision at a real or fictional firm: ambiguous data, competing stakeholders, no single correct answer. Case studies are flight simulators for executives, and MBA programs run on them.

Under partial-credit scoring, the top models hover near 88%. Sounds like an A. But that metric grades AI like a student. The Complete Answer score requires satisfying every rubric criterion, and the best model (Claude Fable 5) manages just 50.9%.

For business strategy, a company needs complete solutions, not a solution that’s partially correct, even if a student might get a good grade from that performance. (GPT Image 2)

Why is the stricter score the realistic one for a strategy executive? Because executive judgment is all-or-nothing. An analysis that nails market sizing but omits the regulatory risk isn’t 88% right; it’s a lawsuit in waiting. A polished draft missing the deal-killing clause is dangerous precisely because it looks finished.

Leading AI models’ ability to solve business school case studies has improved steadily over the last two years, progressing at 17.4 percentage points per year.

The best Complete Answer score rose from 13.2% in April 2024 to 50.9% in June 2026: a gain of 37.7 percentage points in 26 months, or 17.4 percentage points per year. Today’s verdict: poor. No company should let AI decide strategy when it fails half the time. But run the line forward: the remaining 49.1 points take 2.8 years, hitting 100% around April 2029. (One caveat: the newest generation gained only 1.1 points over its predecessor, so my best guess is the date slips a bit. Linear extrapolation near a ceiling flatters the forecaster.)

Even though AI is not there yet in terms of full strategic abilities, progress has been remarkable and may reach the goal around 2029 (or maybe 2030, when we expect superintelligence, in the likely case that the last steps up will be harder to come by). (GPT Image 2)

Today, let AI ideate on possible business strategies and useful questions to investigate. You can even have it draft your strategy as long as you keep a human hand on the yoke to catch the missing criterion. But practice now. In 3 years, we may find that the machine runs the company better than your MBA hires do.

Start practicing with AI for business strategy now. It’s already a good sparring partner, if not ready for the top job yet. (GPT Image 2)

AI Raised the Floor but Lowered the Ceiling in Children’s Storytelling

A new study of 40 elementary school children (grades 2–6) found that an AI storytelling tool narrowed the quality gap between the strongest and weakest young storytellers by a whopping 83.5%. That sounds like the skill-gap compression I’ve reported repeatedly for adults. It isn’t. This gap closed from both ends: the weakest kids improved substantially (nice), but the best kids got worse (not nice at all).

(GPT Image 2)

Min Fan and colleagues from the Communication University of China and the MIT Media Lab had each child in a Chinese elementary school create an illustrated story twice: once with paper storyboards, and once with StoryPrompt, an AI system where the child composes 6 paragraphs, each anchored by an AI-generated keyword (GPT-3.5 offers 8 options per paragraph), plus a Stable Diffusion comic illustration for each. Blind to condition, 5 expert raters scored every story on creativity, richness, coherence, and narrative structure (1–5 scales, judged against grade-level expectations). (The paper re-analyzes the dataset behind the team’s CHI 2025 publication.)

The bottom third of storytellers gained an average of 0.81 points under AI, with the biggest jumps in creativity (+1.29) and richness (+1.37). These are big gains on a 1–5 scale. The top third lost 0.29 points, with the damage concentrated in coherence (−0.43) and narrative structure (−0.56). Baseline skill correlated with AI gain at a staggering −0.73. And no, the best kids didn’t simply run out of scale: they averaged 3.8 of 5, leaving ample headroom. AI decoupled the content dimensions from baseline skill; structure stayed stubbornly tied to each child’s own competence.

The decline at the top contradicts the adult evidence. When Boston Consulting Group consultants worked with GPT-4, both halves of the skill distribution improved: the bottom half gained 43% and the top half 17%. Customer-support agents showed the same one-sided lift: 34% for the weakest workers, with the top essentially unchanged. Even in adult creative writing, Doshi and Hauser found the least-creative writers gained over 10% in novelty while the most creative merely flatlined. Adults at the top stalled; they didn’t sink. So why did the best children sink?

The likely culprit is forced scaffolding. In the adult studies, AI was an offer the expert could refuse; a BCG consultant could glance at GPT-4’s suggestion and ignore it. StoryPrompt made the AI mandatory: every paragraph anchored on a system keyword, no custom input, no skip button. Children defer where adult experts would override, so compulsory design quietly converts an unwanted suggestion into a lower score. Make AI an offer, not an order.

Here are 3 design guidelines for AI features, for kids and grown-ups alike:

1. Build escape hatches for strong users. Every AI assist needs skip, dismiss, and type-your-own affordances. “Flexibility and efficiency of use” has been usability heuristic 7 since 1994, and mandatory scaffolding is its inversion.

2. Adapt support to the user’s actual constraint. The authors call this “mechanism-contingent scaffolding.” Two kids with identical low scores may need opposite help: one lacks ideas; another has ideas trapped behind execution burdens. One girl’s story grew from 81 to 476 characters once AI images freed her from laborious drawing.

3. Cap the rabbit holes. One boy regenerated illustrations 30 times (22 on a single paragraph); the unlimited regenerate button turned a support feature into a cognitive sink while his story starved. Guided iteration that asks the user what should change beats a free-spinning slot machine.

The Infinite Canvas: Unlimited Space Meets Limited Users

An infinite canvas discards the page in favor of an unbounded, zoomable plane where users place anything anywhere, the model behind Miro, FigJam, and Apple Freeform. Spatial freedom is a genuine cognitive asset, but unbounded space breeds two predictable diseases: disorientation and sprawl, so every infinite canvas must buy back usability with landmarks, a minimap, and a 1-keystroke way home.

The infinite canvas, rendered literally: the workspace unrolls in every direction, and so does the content. Without landmarks and a way home, half of these sketches will never be seen again. (GPT Image 2)

Definition: An infinite canvas is a 2-dimensional workspace with no fixed boundaries, navigated by panning and zooming, on which users place heterogeneous objects (sticky notes, shapes, images, documents, embeds) at any position and any scale.

The page metaphor that has governed documents since Gutenberg imposes edges, and edges impose sequence. A canvas imposes neither. The screen becomes a viewport onto a plane that extends as far as the user’s content does, which is liberating right up until the moment it isn’t.

A Comics Theorist Named It; HCI Researchers Built It

The term arrived from an unexpected bailiwick: comics. Scott McCloud coined “infinite canvas” in his 2000 book Reinventing Comics, arguing that online, the monitor should be treated as a window onto an unbounded surface rather than as a page, freeing stories to run vertically, diagonally, or in spirals. (By his own account, most print cartoonists concluded he had taken leave of his senses.)

Human–computer interaction research had been building the machinery all along: Ivan Sutherland’s Sketchpad demonstrated direct manipulation on a drafting surface in 1963, and Pad++, the zoomable interface built by Ben Bederson and Jim Hollan in 1994, made infinite pan-and-zoom the primary navigation model. Products caught up 2 decades later: RealtimeBoard launched in 2011 and renamed itself Miro, Figma shipped FigJam in 2021, and Apple entered with Freeform in 2022. The 2020–2021 shift to remote work turned the category from curiosity into standard equipment, because distributed teams needed a substitute for the whiteboard wall they had lost.

Why Infinite Canvases Work: Space Is a Cognitive Resource

4 usability advantages justify the pattern:

• Spatial memory: people remember where they put things, so “the budget cluster is upper left” retrieves information without naming, filing, or searching for it.

• Deferred structure: documents and outlines demand hierarchy before understanding exists, whereas a canvas lets 60 sticky notes sit adjacent until the grouping emerges, which is exactly how affinity mapping works. Premature structure taxes thinking.

• Zoom as a detail dial: wheel out for the whole argument, wheel in for one note’s fine print, with no navigation between separate overview and detail screens.

• Real-time collaboration, where the canvas beats the alternative outright: 8 cursors moving on one shared board beat 8 people narrating their screens to each other.

How Infinite Canvases Fail: Desert Fog and Canvas Drift

Research named the first disease before most canvas products existed. Susanne Jul and George Furnas (my erstwhile colleague from Bell Communications Research) coined “desert fog” at UIST 1998: the state in which the current view contains nothing whatsoever on which to base a navigation decision. Zoom 2 wheel-clicks too far into an empty region and every direction looks identically blank. No landmarks, no gradient, no clue. What do users do in desert fog? Not search methodically. They flail, and then they quit. The remedies Jul and Furnas prototyped (residual landmarks and view-tracking aids) anticipated today’s minimaps by a quarter century.

The second disease develops over weeks, and I call it canvas drift: content dispersing across unbounded space until the board becomes an archaeological site, with strata of stale stickies, half-finished diagrams stranded 40,000 pixels from anything, and duplicate clusters nobody dares delete. Unlimited space means never being forced to clean up. So nobody cleans up.

Add three more costs: the blank start (an empty infinite plane is blank-canvas paralysis at industrial scale), text that turns illegible at the wrong zoom level, and the genuine difficulty of conveying a freeform 2-dimensional arrangement to keyboard and screen-reader users. None of these kills the pattern. All of them demand payment, in the currency listed below.

9 Design Guidelines for Infinite Canvases

1. Bind zoom-to-fit to 1 keystroke. One press must frame all content; this is the antidote to desert fog, and no user should stay lost for longer than a second.

2. Provide a minimap. A persistent overview showing the viewport’s location gives users the “you are here” that unbounded space otherwise lacks.

3. Ship landmark primitives. Named frames or sections give the plane geography, feed a table of contents, and give collaborators addresses to meet at.

4. Make search teleport. A matching object is worthless if the user can’t reach it; results must fly the viewport to the hit, animating the travel so orientation survives.

5. Give every view a URL. Deep links to a specific region and zoom level let people share “look at this” instead of “pan left, no, my left.”

6. Never start truly blank. Templates, starter frames, and example boards convert the intimidating void into a fill-in-the-blanks exercise.

7. Keep text legible across zoom levels. Render frame titles and key labels at readable sizes even when zoomed far out, so the overview communicates instead of dissolving into specks.

8. Expose an object outline for accessibility. A navigable list of the canvas’s contents gives keyboard and screen-reader users a road into a space that offers no reading order.

9. Build gardening into the workflow. One-click archiving of stale regions and periodic cleanup prompts fight canvas drift; infinite space is the promise, and maintained landmarks are what keep it.

UX Hero: Scott McCloud

It may seem strange for me to include Scott McCloud in my series of UX hero portraits. He draws comics, not dialog boxes, yet his 1993 masterpiece Understanding Comics has taught designers more about visual communication than a shelf of HCI textbooks. Scott’s central lesson, that simplified images often communicate more than photorealistic ones, matters even more now that AI will render anything in any style.

Two dots and a line. That’s a face, and your brain can’t refuse to see it. McCloud built his 215-page treatise (itself drawn as a comic; the man eats his own dog food) around this everyday miracle: stripping an image to its essentials doesn’t weaken the message; it concentrates it. He named the principle amplification through simplification. A photograph is one specific person. A cartoon face is everybody, so readers pour themselves into it and attend to the idea rather than the rendering.

My infographic only gives you a glimpse of Scott McCloud’s many insights. I strongly recommend buying his trilogy, Understanding, Reinventing, and Making Comics. They are old, but so what? Their insights are evergreen, which sort of proves the point. (GPT Image 2)

McCloud’s second gift is “closure”: readers mentally complete the action between panels. Comics never show everything; they trust the audience to participate. Sound familiar? Every wizard, onboarding flow, and progress stepper works the same way: users construct continuity between screens, and the design succeeds when those gaps are effortless leaps rather than chasms. Andy Hertzfeld, co-creator of the Macintosh, called Understanding Comics “one of the most insightful books about designing graphic user interfaces ever written.” Google agreed, hiring McCloud in 2008 to explain the Chrome browser as a comic (39-page web comic).

Fast-forward 33 years, and image models cough up photorealism by the gallon, so the temptation is to use them because they’re nearly free. Resist. That temptation is the fidelity fallacy: assuming that more rendering equals more communication. When every style costs the same prompt, the level of abstraction becomes a genuine design decision, and I want you to make it on purpose. So the next time you generate an illustration, don’t ask the model what to add. Ask what to remove.

Draw Less, Say More: Two dots and a line still beat 4K photorealism for most explanatory jobs. And that’s why a comic book artist earns his place on my list of user experience heroes. On a personal note, Scott is a great guy, and I enjoyed many dinners with him back when we toured together to teach people about usability (me) and visual communication (him).

Brilliant AI Video: Homer’s Epics Animated

A strong recommendation to watch David Comfort’s video “The Odyssey” (YouTube, 6 min.), but only if you’re highly intellectual and well-versed in both The Iliad and The Odyssey, as well as classic art history. Contrary to its name, the video covers both of Homer’s epic poems, and it assumes that you already know both stories, so it’s not for beginners.

The reason I like it (and the reason I also say that it’s only for people with a solid grounding in art history) is that the creator used AI to animate a range of classic history paintings (some famous, some less so) that show various scenes from the story, including some “prequel” scenes such as the Judgment of Paris, where Prince Paris of Troy was tasked with awarding the golden apple to the most beautiful of the three leading Olympian goddesses, Hera, Athena, and Aphrodite. Each goddess offered a bribe, but Paris, playboy as he was, took Aphrodite up on her offer of using (or misusing) her power as the Goddess of Love to make the world’s most beautiful mortal woman fall in love with him. (Thus, the subsequent tribulations of Helen of Troy.)

The new video makes good use of AI to animate some of the many classic history paintings that depict scenes from the Homeric myths. Top: Paris awards the golden apple to Aphrodite, antagonizing Hera and Athena, which was not a good idea just before initiating a war, since they were the Queen of the Gods and the Goddess of War, respectively. Middle: The Greek hero Achilles has finally stopped moping in his tent to fight the Trojan champion, Hector. Bottom: Odysseus has himself tied to the mast so that he can hear the siren song without going to his doom. Unless you already know all these plot elements, the new video won’t make much sense. Just imagine trying to decipher the above illustration if high school failed you and you didn’t gain a proper understanding of the classics. I added explanations because I know most high schools are terrible these days. (Muse Image)

One thing I don’t like about the video is that the soundtrack consists of more-or-less Homeric verses in Greek, set to music. True, the bards used to sing the poems, which is why they famously start with “Sing, Muse, about …” (either the wrath of Achilles or the man of twists and turns, AKA Odysseus). Authentic, yes. Listenable, no. (For my music video version of Moby Dick, I used a rockabilly song for your listening pleasure, inauthentic as that genre is for the period.)

Despite recognizing that David Comfort’s video will go over the heads of 99% of the viewing public, I applaud him. It’s exactly the point of AI filmmaking that it’s so cheap that it supports niche efforts aimed at a small audience. It’s much more fun for the 1% who appreciate something like this to watch a niche video than a generic mass-audience entertainment product from the legacy studios, especially as the production values of the two are converging fast, thanks to rapidly improving AI video models.

The Goal-Gradient Effect: Users Accelerate When They See the Finish Line

People invest more effort the closer they get to a goal: rats in 1932, coffee buyers in 2006, your users today. Show honest progress, grant genuine head starts, and make the final step the lightest. Fake progress works exactly once, and then it costs you the user’s trust forever.

Motivation is a slope, not a flat line: as the finish nears, the walker’s pace picks up all by itself. Design puts the finish line in view.

Definition: The goal-gradient effect is the tendency to increase effort as the remaining distance to a goal shrinks.

The name and the finding are nearly a century old. In 1932, the behaviorist Clark Hull of Yale reported in Psychological Review that rats running a straight alley toward food ran measurably faster the closer they got to the goal box. He called it the goal-gradient hypothesis, “gradient” because effort isn’t constant along the path: plot motivation against remaining distance and you get a slope that climbs as the distance falls. The finding then hibernated in the animal-learning literature for 7 decades.

Rats have much to answer for: they are behind many of the psychology insights we apply in UX design today. (GPT Image 2)

The resurrection came in 2006, when Ran Kivetz, Oleg Urminsky, and Yuhuang Zheng published “The Goal-Gradient Hypothesis Resurrected” in the Journal of Marketing Research. Watching a real café’s buy-10-get-1-free program, they found customers bought coffee more frequently as the free cup approached. Internet users earning reward certificates for rating songs visited more often, rated more per visit, and persisted longer near the goal. Humans, it turns out, run Hull’s software too.

Two companion findings matter for design. First, illusionary progress works: customers handed a 12-stamp card with 2 bonus stamps already applied completed their 10 required purchases faster than customers holding a plain 10-stamp card, despite identical real effort. Joseph Nunes and Xavier Drèze confirmed the phenomenon the same year with their endowed-progress study in the Journal of Consumer Research: among 300 car-wash customers, a 10-slot card with 2 free stamps was completed by 34%, versus 19% for a blank 8-slot card. Same 8 purchases, nearly double the completion. Second, post-reward resetting: the moment a reward is collected, effort slumps back to the bottom of the gradient and must climb all over again.

Partly filled loyalty cards motivated customers to buy even more. (GPT Image 2)

Progress Users Can See Is Progress They’ll Finish

The design translation is direct: make the remaining distance visible, and shrink it honestly. A checkout that announces “Step 2 of 4” recruits the gradient; a checkout of unknown length recruits nothing, because there’s no slope without a visible finish line. Profile-completeness meters, onboarding checklists, and upload percentages all work the same lever, and the good versions endow progress legitimately: if creating the account genuinely completed step 1 (because you transferred the user’s information from the checkout flow), show step 1 checked. That’s the 2-stamp head start with a clear conscience, and it converts a task “not yet begun” into a task “already underway,” which is psychologically a different task.

Sequencing matters as much as display. Front-load quick wins so early progress comes cheap, and make the final step the lightest of all, since that’s where motivation peaks and where a sudden demand for a scanned utility bill does maximum damage. Amazon understood terminal-step compression so well that it patented 1-Click ordering back in 1999. And because of post-reward resetting, completion screens should immediately surface the next meaningful goal; a user at the top of one gradient is standing at the bottom of another, whether you design for it or not.

Progress Theater: The Dark Side of the Gradient

Now the abuse, which I’ll call progress theater: progress displays that perform advancement without reporting it. The repertoire is familiar. Progress bars that sprint to 99% and then meditate. Flows that promise “2 steps left” and then spawn step 5 of 4. Meters proclaiming “Your application is 90% complete!” when the user has done nothing, a specious endowment that insults rather than motivates. Completeness scores that guilt people into publishing personal data they’d rather withhold. And streak mechanics that flip motivation into hostage-taking: miss 1 day and lose 300 days of visible history, converting a cheerful gradient into dread. (Fairness requires noting that Duolingo, the poster child of streak pressure, also ships streak freezes and repairs, which is the humane version of the mechanic. The tool isn’t evil; the tuning decides.)

Fake momentum isn’t motivating. (GPT Image 2)

The economics of progress theater are terrible, and that’s the case against it in a sentence: the goal gradient runs on believed progress, so the first fake bar a user catches devalues every honest one you’ll ever show. The fixes follow directly. Tie every indicator to real system state. Freeze the step count before the flow ships, and never let it grow midstream. Endow only work genuinely done, with the reason stated. Let streaks bend instead of shatter. And make abandoning a flow shame-free, because a user who leaves respected returns; a user who leaves manipulated doesn’t.

8 Design Guidelines for the Goal-Gradient Effect

1. Show position in every multi-step flow. “Step 2 of 4” beats an anonymous sequence; unknown length flattens the gradient.

2. Keep the step count immutable. Steps may collapse, never multiply, once a flow has started.

3. Grant honest head starts. Pre-check steps the system truly completed, and say why they’re checked.

4. Front-load quick wins. Cheap early progress gets users onto the slope; save nothing easy for step 1’s graveyard.

5. Make the last step the lightest. Motivation peaks at the end; friction there wastes the entire gradient you built.

6. Tie indicators to real state. A progress bar is a measurement instrument, not an animation; no decorative loops.

7. Bridge the post-reward slump. On completion, celebrate briefly and surface the next meaningful goal immediately.

8. Instrument per-step abandonment. Expect drop-offs early, where the goal is distant, and invest your polish there.

Look once more at the walker in the illustration: the pace quickens not because the path got easier but because the flags and the light made the remaining distance legible. That’s the entire craft. You can’t install motivation in users, but you can reveal the finish line their motivation already responds to, and you can refuse to lie about it. Show real progress, and users finish; stage fake progress, and they finish with you.

Let users see that the finish line is getting close, and you can boost their motivation to complete the process. (GPT Image 2)

User Spending on AI Subscriptions Up 41% in Two Years

Users keep spending more on AI, which is the best indication that it has value. PNC is one of the largest U.S. financial services institutions, with annual revenues of $33 billion. It recently published an analysis of its credit card customers’ spending on AI services (PDF file). The data showed that an increasing share of these consumers is paying for AI subscriptions on their PNC credit cards.

AI is hungry for more money, and consumers are starting to pay up. (GPT Image 2)

More interestingly, the amount these customers are paying is also increasing, as shown in the following chart:

Monthly AI spending in households with AI subscriptions: up 43% in two years. Data from PNC Economics Research. (GPT Image 2)

In only two years, the average AI spending per household increased from $22 in May 2024 to $31 in May 2026: up 41%, for an annualized growth rate of 19%. (This is averaged over those households that have at least one AI subscription, not all households. Most people still use only free AI and miss out on the vastly better paid models.) But a closer look at the chart shows that almost all of the growth happened after January 2026.

Premium AI is much better than free AI. (GPT Image 2)

For the best frontier models, you need to go beyond the $20 starter plans and pay $100+ per month, which clearly most households aren’t doing yet. (GPT Image 2)

From May 2024 to January 2026, the annualized growth in subscriber spending on AI was “only” 10%, but from January to May 2026, it was 80%. The AI spending curve idled for 20 months, then floored the accelerator.

This is a major surprise to me, and a perfect example of why we rely on empirical data rather than personal intuition. I would have thought that the main driver of personal AI spending was creative services like image and video generation, both of which were going strong in 2025. In contrast, the strong growth area in 2026 so far has been agentic AI, which I had assumed was more a matter of company spending than individual household spending.

Of course, some of the AI subscriptions billed to personal credit cards may really be business expenses that employers reimburse. More detailed data would be needed to tease apart the two kinds of spending charged to personal credit cards.

Is AI use at home truly personal, or is it business? The credit card data can’t say. (GPT Image 2)

How high can AI expenses go? There’s still a long way to the scenario in this cartoon, and even though I expect AI to double household incomes after we get superintelligence, I don’t think personal AI spending will grow beyond 10% of household budgets unless we include spending on robots to do the housework and robocars to drive us. Butlers and chauffeurs are more valuable to most people than the ability to analyze reports or draw funny cartoons. (GPT Image 2)

AI Taught Students to Ask Better

AI improved learning in one of the poorest school systems on Earth. In a controlled experiment in Sierra Leone, 1,763 students in grades 7–8 swapped half their weekly math periods for sessions with Gemini’s Guided Learning mode. After 9 weeks, treated students scored 0.26 standard deviations (SD) higher than controls (p=0.029), which the researchers translate to 1.2–1.7 years of typical progress in that school system. Students who used AI for 12 hours or more gained 0.38 SD. The ROI is stupendous when measured as years of learning divided by hours spent with AI.

Guided Learning asked scaffolding questions in 76.4% of its messages and handed over direct solutions in only 2.1%. And the users adapted to this design: skill-seeking questions rose from 67.7% to 91.7% of student messages over the trial, while answer-seeking collapsed from 25.1% to 6.3%. One teacher put it plainly: “Gemini is not solving the problem for you... you ask questions, he directs you what to do.” The default behavior of the AI taught the users how to use it. When learning is the goal, the answer is the wrong deliverable.

In contrast to many other studies where AI narrowed skill gaps, in this study the largest gains went to students who started stronger, so the tool widened the achievement gap.

Obviously, higher-IQ students will always learn more, so the question is how much more. In this case, AI helped all students, but it helped the smartest the most. We don’t know why AI widened rather than narrowed the gap in this study, but the cause may be precisely that the AI was not doing the work for the students. If AI had done the homework for the students, it almost certainly would have narrowed the skill gap, but the goal of education is learning, not homework.

Many previous studies have reached the same conclusion: when using AI for education, it should not solve homework problems for students or hand them straight answers, but rather function as a tutor that guides students through the learning process and helps them when they get stuck. Always nice to have established findings confirmed, but the most important lesson from this new study was the AI’s ability to teach students to ask better questions.

Conclusion: New Species, Old Rules

Step back from this week’s items, and two threads emerge. The first: your users are no longer all human. AI agents completed 89% of shopping tasks on an agent-ready website, 41% of shoppers already prefer an AI intermediary to your brand site, and subscriber spending on AI has grown at an 80% annualized rate since January. The customers are changing species, and the money is following them.

The second thread: the old rules govern the new species. The semantic markup that lets agents shop is the same accessibility hygiene we’ve preached for 25 years. The Socratic scaffolding (talk about old insights: Plato rules!) that lifted math scores in Sierra Leone worked for the same reason StoryPrompt’s forced keywords backfired on the best young storytellers: AI must be an offer, not an order. And Hull’s rats (1932), McCloud’s cartoon faces (1993), and Furnas’s desert fog (1998) explain this week’s interfaces better than any vendor demo.

Neither panic nor freeze: publish the structured data, keep a human hand on the yoke, and stack the next small brick. The users changed species; the fundamentals didn’t.

Final Thought of the Day

About the Author

Jakob Nielsen, Ph.D., is a usability pioneer with 43 years experience in UX and the Founder of UX Tigers. He founded the discount usability movement for fast and cheap iterative design, including heuristic evaluation and the 10 usability heuristics. He formulated the eponymous Jakob’s Law of the Internet User Experience. Named “the king of usability” by Internet Magazine, “the guru of Web page usability” by The New York Times, and “the next best thing to a true time machine” by USA Today.

Previously, Dr. Nielsen was a Sun Microsystems Distinguished Engineer and a Member of Research Staff at Bell Communications Research, the branch of Bell Labs owned by the Regional Bell Operating Companies. He is the author of 8 books, including the best-selling Designing Web Usability: The Practice of Simplicity (published in 22 languages), the foundational Usability Engineering (31,233 citations in Google Scholar), and the pioneering Hypertext and Hypermedia (published two years before the Web launched).

Dr. Nielsen holds 79 United States patents, mainly on making the Internet easier to use. He received the Lifetime Achievement Award for Human–Computer Interaction Practice from ACM SIGCHI and was named a “Titan of Human Factors” by the Human Factors and Ergonomics Society.

· Subscribe to Jakob’s newsletter to get the full text of new articles emailed to you as soon as they are published.

· Follow Jakob on LinkedIn.

· Read: article about Jakob Nielsen’s career in UX

· Watch: Jakob Nielsen’s first 41 years in UX (8 min. video)

Summary: Almost every screen you design is assembled from 10 basic interaction elements: buttons, forms, menus, links, dialog boxes, alerts, icons, checkboxes and radio buttons, tabs, and search. Each is decades old but still misused daily. This article defines the GUI design alphabet, traces its history, and distills 86 evidence-based design guidelines, plus bonus coverage of windows and the pointer.

The 10 design components you must master to build any modern user interface.

The graphical user interface (GUI) runs on a small vocabulary. Strip away the branding, and nearly every screen you used today was assembled from roughly a dozen standard parts: a button here, an input field there, a menu across the top, links in the middle, and a dialog box interrupting at the worst moment. This set is our interaction alphabet: just as 26 letters suffice to write every English word, about 10 elements suffice to compose almost every user interface ever shipped. Screens differ endlessly. The letters don’t.

The 10 sort into families as neatly as the chemical elements in the periodic table: buttons act; forms, checkboxes, and search take input; menus, links, and tabs get you there; dialogs and alerts are the system talking back; icons are the symbols everything else wears. They even parse as speech acts. The button commands, the alert asserts, the dialog asks, the link promises, the form interviews, and search, alone among them, listens.

I recently published a complete history of the GUI, tracing 64 years from Spacewar! in 1962 to the interactive world models of 2026. (For the 5-minute version with a beat, watch my music video about the GUI (YouTube). I stand by the iPhone-launch B-roll.) The short version: the GUI won not through any single invention but through the synergy of 4 elements, Windows, Icons, Menus, and Pointer, remembered by the acronym WIMP. Together, they turned the computer from a command sequence into a workspace.

That article covered GUI history. Now to GUI practice. Below are the top 10 GUI design elements, ranked by how much of users’ daily interaction rides on each. For each, I define it, trace where it (and often its odd name) came from, explain how it helps usability, warn where misuse hurts, and close with guidelines you can apply tomorrow. Two of the four WIMP letters (icons and menus) earn top-10 slots on their own merits; the other two (windows and the pointer) get a bonus section, because designers now inherit them more than they design them.

Why write about 40-year-old controls in 2026? Because they’re violated daily, and because of Jakob’s Law: users spend most of their time on other sites and apps, so they expect yours to work like everything else they already know. These 10 elements are the “everything else.”

The familiar wins because conventions are a commons. Every product that ships a recognizable magnifying glass deposits a little more collective learning; every novel “insights” glyph withdraws it. And like every commons, the polluter rarely pays. When a site hides desktop navigation behind a hamburger or cross-dresses a link as a button, the hesitation it creates isn’t confined to that site: it degrades a shared asset the next interface depends on. Design has externalities. Please be a good citizen, not the experience polluter.

The tragedy of the commons is so common in economics that it got a name. The original example was overgrazing. UX now adds its own example to join overfishing and traffic congestion: degrading design conventions.

1. Buttons: Press to Make Something Happen

Definition: A button is a self-contained control that executes a single command when clicked or tapped.

The button is the workhorse of interaction design. Whatever else a task involves, it almost always ends with a button press: “Buy Now,” “Send,” “Save,” or the fateful “Delete.” Buttons are the only element that changes the world rather than the view. Links and tabs move the user; menus and dialogs merely rearrange the conversation; a button commits. Money moves, files vanish, messages become unsendable. That asymmetry is why buttons carry the strictest labeling rules in the interaction alphabet: a wrong turn costs a Back click, but a wrong button can cost a customer.

Users traverse your entire design to reach one control: the button that makes something happen. It has earned the pedestal.

The GUI button borrows a century of training from the physical world (doorbells, elevator panels), and early GUIs like the Xerox Star (1981) and the Macintosh (1984) drew buttons with borders and shading to cash in on that training. Don Norman gave the effect its name: perceived affordance. A control that looks pressable invites pressing; a control that looks like decoration invites nothing.

Then fashion intervened. The flat-design wave that crested around 2013 stripped borders and shadows from buttons, leaving users to guess which words on the screen are commands. When everything is flat, nothing invites a press.

The label is a promise about what happens next, so state the outcome with a verb: “Save Invoice,” “Place Order,” “Delete 3 Files.” A bare “OK” forces the user to reread the entire screen to reconstruct what he or she is agreeing to.

Button physics predates the button. Paul Fitts published his law in 1954: pointing time grows with distance and shrinks with target size, so bigger, closer targets are hit faster. Fitts’s law explains why Apple pinned the Lisa’s menu bar to the top screen edge in 1983 (the cursor stops at the edge, giving the target effectively infinite height), and it sets the floor for touch design: the fat-finger problem demands targets of at least 1×1 cm, a guideline most mobile designs still violate.

Fitts’s law in one image: pointing time grows with distance and shrinks with target size. The design translation is blunt: make frequent targets big and close.

A hybrid deserves its own mention: the split button, which fuses a command with a menu. The large zone fires the default action in 1 click (“Reply”), while a smaller attached zone, marked by an arrow or 3 dots, opens the variants (“Reply All,” “Forward”). Microsoft’s Office toolbars popularized the pattern in the 1990s, and it solves a real allocation problem: when 1 command dominates its siblings in frequency, the split button keeps the winner instantly clickable and files the rarities in a menu, precisely the split I recommend in the menus section below. 3 cautions apply. Draw a visible divider between the two zones, or each half collects the other’s clicks. Honor Fitts’s law on the small zone, which is easily undersized. And if no single default dominates, use a plain menu button instead; a split button with nothing to promote is a menu button with extra borders.

1 pedestal, 2 targets: the split button gives the default action the big zone and tucks the variants behind the small one. The size ratio is the message; frequency of use buys the bigger share of the button.

Finally, unavailable commands. Don’t hide a temporarily disabled button, and don’t let it masquerade as active: show it in a muted version of the primary color, with an explanation of why it’s inactive and how to activate it. I analyzed the evidence in Inactive GUI Controls: Show, Disable, or Hide?

Here are 8 design guidelines for buttons:

1. Make buttons look pressable. Contained shape, contrast against the background, and a visible state change on press.

2. Label every button with a verb stating the outcome. “Save Invoice,” never a bare “OK.” If the effect won’t fit in 2–4 words, the problem is deeper than the label.

3. Give each screen exactly 1 visually dominant primary action. Two competing primaries mean no true primary.

4. Respect Fitts’s law. Frequent actions get big, close targets, and touch targets measure at least 1×1 cm.

5. Acknowledge every press within 0.1 seconds. That’s the response-time limit for an interface to feel like it reacted.

6. Show disabled buttons in a muted version of the primary color, plus an explanation. Users deserve to know the feature exists and what would unlock it.

7. Use buttons for actions and links for navigation. Users decode the two visual languages differently; don’t cross-dress them.

8. Place the button where the task ends. After the fields, after the content, at the natural end of the reading flow.

2. Input Fields and Forms: Where Money Changes Hands

Definition: A text input field is a bounded area where the user types or edits data; a form assembles related fields into a unit that ends in a submit button.

Forms are where money changes hands: checkout, signup, lead generation. Thus, form usability converts into revenue with unusual directness. UX = profits, and nowhere is the equation shorter than in a form.

The simplest of all GUI design elements: the humble text input field. Since text is so versatile, you’ll use this a lot, unexciting as it is.

A form is a machine that converts attention into revenue: labels, fields, validation, submit. Every needless part jams the machine.

The core guidelines are old, verified, and ignored. Every field needs a persistent label, because placeholder text inside the field evaporates at the exact moment the user starts typing, which is the exact moment he or she may need it. Input formats should flex: computers exist to format data, so accept phone numbers with or without dashes and clean them up in code. Error feedback belongs next to the offending field, in plain words, with the user’s data intact. (Wiping a half-completed form because 1 field failed remains a capital offense. It still happens often enough to rank 10th on my list of top UI annoyances.)

Match the control to the data. A task that involves dates, such as booking an airline ticket, deserves a date picker rather than a naked text field and a prayer about formats. Commerce needs controls that match how shoppers think: a mini trash-can icon to remove an item from the cart, because users don’t conceive of “not buying” as “setting the quantity to 0.” Their mental model is removal, so give them removal.

Specialized tasks can benefit from specialized input controls on the form. The date picker is standard (meaning that users understand it) and prevents many errors.

But the strongest form guideline is subtraction. Every needless field costs completions. Even an optional field levies a field tax: users must notice it, interpret it, decide whether it applies, and verify that skipping it is safe. Optional in the database is not optional in the user’s attention.

Survey methodologists have quantified this burden for decades: the U.S. Census Bureau estimates respondent minutes the way engineers estimate latency. One finding transfers from the Census to your website: perceived burden predicts abandonment better than actual burden. A form can drive users away before they’ve typed a character. There’s a counterintuitive fix: print the burden. “3 questions, 40 seconds” converts dread into a bargain. Governments are legally required to publish burden estimates for their paperwork; a form that volunteers its own signals a confidence most sites can’t fake. (But tell the truth: saying a form will take a minute when it requires 5 will lose any trust people have in your brand.)

The classic case: Expedia reported gaining an extra $12 million a year after deleting 1 optional field (“Company”) from a booking form, because customers typed their bank’s name there, then the bank’s address, and failed payment verification. Interrogate every field you’re tempted to mark as required: would you rather have the data or the sale? The best form field is the one you don’t have and users don’t have to deal with.

Here are 8 design guidelines for input fields and forms:

1. Delete every field that isn’t strictly needed. Each field you cut raises completions; each field you keep must justify itself against lost revenue.

2. Give every field a persistent label outside the field. Placeholder text is a hint, not a label; it disappears when typing starts.

3. Accept flexible input formats. Rejecting “(555) 123-4567” because you wanted “5551234567” is the computer delegating its job to the human.

4. Place error messages next to the offending field, and preserve everything the user typed. A form that punishes errors by destroying work won’t be completed twice.

5. Use specialized controls where they fit the task. Date pickers for dates, and a trash-can icon for removing items from a cart or list.

6. Lay out forms in a single column with related fields grouped. Multi-column layouts create ambiguous reading orders, so users skip fields.

7. Label the submit button with the outcome. “Place Order,” not “Submit,” so the final click carries no doubt.

8. Don’t validate half-typed input. Yelling “invalid email” mid-keystroke is premature judgment; validate when the user leaves the field.

3. Menus: Information Architecture Made Visible

Definition: A menu is a list of commands or navigation options that stays hidden until summoned.

Menus deliver two benefits at once. They save screen space, and they support recognition over recall (usability heuristic 6): users pick from visible choices instead of remembering command names. That trade is the founding bargain of the GUI, and the name comes from the restaurant: a menu lists what the kitchen can make, and you can’t order what isn’t on it. That second clause is the whole caveat.

A menu, unlike a search box, is a completeness claim: users read it as the full inventory of what the kitchen can make. That’s the hidden epistemology of navigation: menus enumerate; search and prompts allow infinity. Choose menus when the possibility space fits on a card and search when it doesn’t. And anything filed under a label users won’t open isn’t hard to find; as far as the user is concerned, it doesn’t exist.

The dropdown’s bargain: 5 options rent the screen space of 1. The label on the closed state decides whether users ever see these options.

The Xerox Star shipped the first fixed drop-down menus in 1981, replacing the pop-up menus users kept losing. Apple pinned the menu bar to the top of the Lisa screen in 1983 (Fitts’s law at work again). Cascading menus added hierarchy, mega-menus supersized the dropdown for 2000s e-commerce, and the mobile hamburger (3 stacked lines, drawn by Norm Cox for the Xerox Star in 1981) got resurrected 3 decades later. Microsoft’s Office Ribbon (2007) hybridized menu and toolbar. (Credit where due: the Ribbon was a serious, user-tested attempt to tame 1,000+ commands, and its grouped, labeled icons follow half the guidelines in this article.)

Mega menus open the door to many more options in one place, which can improve the information scent of the site’s categories by defining them through examples.

The hamburger menu has its place on mobile screens where space is at a premium. On large desktop monitors, it risks being overlooked.

The Microsoft Ribbon was a great advance in menu design. Too bad it’s almost never encountered outside Microsoft Office.

Menu structure is information architecture made visible. The category names decide whether users find a feature or conclude it doesn’t exist: a feature filed under a vague label like “Solutions” or “Resources” is a feature lost. And the famous 7±2 limit doesn’t apply, because visible items don’t tax working memory. A long, well-labeled menu beats a short cryptic one every time.

The top navigation bar is your information architecture printed where everyone can see it. The 6 words you pick decide which features exist in users’ minds.

Countless pixels have been spilled arguing over top versus side navigation on websites. The answer: it doesn’t matter. Both are standard patterns that users know and love.

Side navigation has the advantage of allowing for a longer list of options. Since users can see and scan the options, they don’t need to keep them in memory, so don’t worry about Miller’s Law (the 7±2 memory limit).

The classic failure mode is the hover-opened cascading menu with a hair trigger: the user aims diagonally at a submenu item, the pointer crosses a neighboring entry, and the whole structure collapses mid-flight. Depth compounds the risk. The hamburger deserves its own warning: a defensible compromise on a phone, a self-inflicted wound on a desktop, because navigation users can’t see is navigation they won’t use. Out of sight, out of mind, out of business.

Cascading menus descend from Products to Ultrabook in 5 levels. Every added level multiplies both the pointing precision required and the chance that 1 wrong pixel collapses the stack.

My 7 design guidelines for menus:

1. Name categories in the users’ vocabulary, verified with card sorting and tree testing. Your org chart is not an information architecture.

2. Prefer click-to-open over hover-to-open. If you must use hover, add a short delay and a diagonal tolerance path.

3. Limit cascades to 2 levels. If the hierarchy needs more, restructure the categories rather than deepening the cascade.

4. Show top-level navigation on desktop screens. Reserve the hamburger for small screens where space truly forbids visible options.

5. Mark the user’s current location in navigation menus. A nav bar without it is a map missing the “you are here” dot.

6. Order items by importance and task frequency. Alphabetize only when users know the exact name of what they seek.

7. Keep the 2–3 most frequent commands out of menus entirely. Promote them to visible buttons; menus are for the long tail.

4. Links: The Atom the Web Is Built From

Definition: A hypertext link is text (or an image) that transports the user elsewhere when clicked.

The link is the atom the web is built from. Vannevar Bush sketched associative trails between documents in his 1945 essay “As We May Think,” Ted Nelson coined the word “hypertext” in 1963, Doug Engelbart demonstrated working links in 1968, and Tim Berners-Lee shipped the web in 1991. NCSA Mosaic colored links blue and underlined them in 1993, and the convention stuck. (I wrote my first book on the topic, Hypertext and Hypermedia, in 1990, back when links were a research area rather than the planet’s plumbing.)

A link makes two promises: that it can be clicked, and what awaits on the other side. The first promise is visual, and color plus underline remains the strongest signal. The second promise rides on the wording, what Peter Pirolli and Stuart Card at Xerox PARC called information scent: users predict the destination from the label the way an animal follows scent to food. “Click here” and “learn more” have zero scent. Worse, scanning users often read only about the first 11 characters of a link, so a page full of “Learn more” links reads as “Learn more, learn more, learn more.” Nothing learned.

A link is a bridge between two islands of content. Blue and underlined remains the strongest signal that the bridge will hold your weight.

One boundary matters above the rest: links go places; buttons do things. Blur the two visual languages, links dressed as buttons and buttons dressed as links, and users hesitate before every click, paying a small tax across the entire interface.

The 7 design guidelines for links:

1. Make links look like links. Color plus underline for links inside text; color alone fails colorblind users and cheap screens.

2. Reserve link formatting for links. Underline nothing else, or you’ve trained users to click furniture.

3. Front-load the information-carrying words. The first 11 characters do most of the work when users scan.

4. Write link text that predicts the destination and makes sense out of context. Screen-reader users pull up lists of all links on a page; 14 “click here” entries make a useless list.

5. Differentiate visited from unvisited links in link-heavy designs. Showing where users have already been prevents accidental revisits and supports wayfinding.

6. Don’t dress links as buttons or buttons as links. The visual grammar carries meaning; garbling it costs a moment of doubt on every click.

7. Open links in the same tab by default. When you make an exception, flag it in the link, e.g., “(PDF).”

5. Dialog Boxes: Interruptions Must Earn Their Keep

Definition: A dialog box is a secondary window that interrupts the main flow to ask a question, collect a decision, or deliver news the user must acknowledge. A modal dialog blocks all other work until dismissed; a modeless dialog lets work continue.

The name is straightforward: a dialog is a conversation between the system and the user. Like any conversation partner, it’s judged by whether the interruption was worth it.

The Macintosh codified the grammar in 1984: message, OK button, Cancel button. That grammar contains the classic trap. Outcome labels beat OK/Cancel, because “Delete 3 Files” versus “Keep Files” survives contexts where OK/Cancel collapses. Ask “Do you want to cancel your subscription?” above a “Cancel” button, and nobody knows what happens next.

Interruption taxes attention. A modal dialog yanks the user out of his or her task, and the working memory holding that task pays the bill. So a modal must earn the interruption: a blocking decision, an irreversible consequence, an input without which nothing proceeds.

Modal dialog boxes hold the user’s task hostage until they get an answer.

Everything else belongs inline or in a modeless panel. Beware confirmation fatigue, too: pepper users with “Are you sure?” for trivial acts, and they’ll learn to dismiss on reflex, and the reflex will also dismiss the 1 confirmation that mattered. For reversible actions, undo beats asking.

Modeless dialog boxes usually have superior usability: the conversation stays open, and so does the work.

The web shows what happens when this element escapes adult supervision: pop-up ads (invented at Tripod.com in the late 1990s; the responsible programmer, Ethan Zuckerman, has since apologized in print, and I accept on behalf of the world’s users), cookie-consent walls stacking up since 2018, and newsletter overlays demanding commitment before the visitor has read a single paragraph. Some of this is ignorance, and some is deliberate dark design. Either way, users pay.

The company pays too; it just gets a delayed invoice. Analytics credit the overlay for the 3% who subscribed and record nothing for the 97% who frowned. Resentment has no event handler. Dark patterns persist partly because their costs are real but uninstrumented, surfacing weeks later as unsubscribes and churn, unattributed. If you must run an overlay, measure what it costs, not just what it bullies into being.

The popup crashes through the wall of the user’s task, uninvited: 30% off the merchandise, 100% on the resentment. Every survey of hated advertising formats I’ve seen since the 1990s puts it at #1.

8 design guidelines for dialog boxes:

1. Go modal only for genuinely blocking decisions. If the user could reasonably keep working, the interruption wasn’t earned.

2. Label the buttons with outcomes. “Delete 3 Files” and “Keep Files” answer the question; “OK” and “Cancel” obscure it.

3. Make the safe choice the default, and let Esc always cancel. A stray Enter keystroke should never destroy anything.

4. Ask 1 question per dialog, in 1–2 sentences. Situation, consequence, choice; a dialog is not a reading assignment.

5. Prefer undo to confirmation for reversible actions. Undo protects users without training them to click through warnings.

6. Use modeless dialogs when work can continue. Find-and-replace solved this in the 1980s.

7. Never greet arriving visitors with an overlay. Asking for the email address before delivering any value is asking to go steady before saying hello.

8. Never stack dialogs on dialogs. A queue of interruptions means the design upstream already failed.

6. Alerts, Notifications, and Error Messages: The System’s Half of the Conversation

Definition: Alerts, notifications, and error messages are the system’s side of the conversation: short announcements that something happened, is happening, or went wrong.

An alert demands the user’s attention by force. Attention is fragile, and every unnecessary alarm leaves another crack.

The formats range from inline validation text to banners, badges, and toasts. The toast earned its name around 2000, when Microsoft’s MSN Messenger notifications slid up from the taskbar like bread from a toaster. That self-dismissal makes the toast fine for confirmations (“Message sent”) and malpractice for anything the user must act on: an error that evaporates in 4 seconds will be rediscovered the hard way.

The toast pops up, confirms, and sinks away on its own. Perfect for “Message sent.” Wrong for error messages, which must persist until the problem is fixed.

Error messages are the most consequential members of the family, and their guidelines predate the GUI itself: say what went wrong in plain language, be precise about where, state how to recover, and never blame the user. I canonized these rules as usability heuristic 9 in 1994, but they were already old wisdom from the mainframe era. MS-DOS’s “Abort, Retry, Ignore?” belongs in a museum, ideally next to the laser printer that said “PC LOAD LETTER.” Yet “An error occurred” still ships in 2026: 4 decades of guidelines, ignored in 3 words. Do better, people!

The error message is a teachable moment, assuming that it actually teaches something by explaining exactly what went wrong instead of being bland and useless.

Two more failure modes deserve naming. First, color-only signaling: roughly 1 in 12 men has red-green color deficiency, so “fields marked in red” communicates nothing to him; pair color with an icon and words. Second, notification spam: every needless notification spends trust that the important one will need. An app that runs up its badge count on trivia trains its users to ignore its badges.

Notification badges are an imposition on users and generate FOMO anxiety. Only use them to count things that users care about.

7 design guidelines for alerts, notifications, and error messages:

1. Write in plain language, never raw error codes alone. “Error 0x80004005” is a message the developers wrote for themselves.

2. Say precisely what went wrong and where. Point to the field, the file, or the step; “something went wrong” helps no one.

3. State the way forward. A good error message is a 1-sentence recovery plan.

4. Never blame the user. Ban “illegal,” “fatal,” “invalid user,” and every phrasing that assigns guilt to the person who trusted your product.

5. Match severity to format. Toasts for FYIs, persistent inline messages for errors that stay until fixed, and modal alerts only for catastrophes.

6. Signal with icon plus color plus words. Redundant coding reaches everyone, including colorblind users.

7. Ration notifications. Default to fewer, let users tune the volume; each interruption withdraws from a finite trust account.

7. Icons: Small Pictures, Big Misunderstandings

Definition: An icon is a small pictogram standing in for an object, an action, or a status.

Icons save space, survive translation, and make toolbars scannable at a glance. David Canfield Smith coined the GUI meaning in 1975, borrowing from the Russian Orthodox tradition in which an icon doesn’t merely depict its subject but embodies its essential properties. The Xerox Star shipped icons commercially in 1981, and Susan Kare drew the Macintosh set in 1984, including the trash can that users still drag things into 42 years later. The floppy-disk Save icon has outlived the floppy disk by two decades: proof that an icon can persist as pure convention, recognized by millions who never touched a floppy.

An icon compresses meaning into a thumbnail-sized picture. The compression is lossy: users decompress unfamiliar icons into the wrong meaning with impressive regularity.

The chronic weakness of icons is that users guess wrong about unfamiliar pictures, and only a handful approach universal recognition: the magnifying glass, the house, the gear, the trash can. Everything else is a hypothesis awaiting a test, hence the guideline of 30 years’ standing: pair icons with text labels unless space truly forbids it. A text label is the cheapest usability insurance you can buy. Every labeled icon is a lesson; every unlabeled icon is an exam. Repeat the pairing often enough and the label teaches the icon until the icon can stand alone, which is exactly how the magnifying glass earned its independence.

Every user knows what the trash can icon does. Keep it.

Familiar icons are convention capital: collective learning accumulated across products and decades. Redrawing a standard symbol spends that capital and sends the bill to every user. Novelty is justified only when the new symbol buys more meaning than it destroys.

Finally, the humblest icon of all: the favicon, born in 1999 with Internet Explorer 5 as the “favorites icon,” 16×16 pixels in size. Its modern job is identification in the chaos of open browser tabs: past 15–20 tabs, page titles truncate to nothing, and the favicon is the only identity your site has left. A distinctive favicon is the smallest billboard your brand will ever buy. Make it legible.

At 16×16 pixels, the favicon is often the only part of your identity that survives in a crowded tab bar. Users hunting for your tab among 30 others navigate by this postage stamp.

7 design guidelines for icons:

1. Pair icons with text labels. Where space truly forbids one, provide a tooltip and accept that you’ve traded learnability for pixels.

2. Use the standard metaphor when one exists. A new symbol for search or settings spends user attention to buy nothing.

3. Test recognition before trusting a metaphor. Show the icon alone to 5 users and ask what it means; hesitation is your answer.

4. Keep a consistent visual style with distinct silhouettes. An icon set should look like siblings that can be told apart at a squint.

5. Don’t redesign learned icons for fashion. Every redesign of a familiar symbol taxes every existing user to please the design team.

6. Ship a favicon that survives 16×16 pixels. Simplify the logo to one strong shape in a brand color; fine detail turns to mud at that size.

7. Reserve icon-only buttons for the universal handful. The magnifying glass can stand alone; your novel “insights” glyph can’t.

8. Checkboxes and Radio Buttons: Squares Say “Pick Any,” Circles Say “Pick One”

Definition: A checkbox toggles one independent option on or off, and a group of checkboxes permits multiple selections; radio buttons present a mutually exclusive set from which exactly 1 choice must emerge.

These sibling controls split the job of selection, and both names carry history. The checkbox comes from paper forms, where you check the box. The radio button comes from mechanical car-radio presets: push 1 button in, and the previously selected button pops out. (Readers of a certain age will remember the satisfying clunk; the rest of you will have to trust us.)

The controls also teach silently. The shape declares the choice model: squares say “pick any,” circles say “pick exactly 1.” Decades of exposure taught users this grammar, so when a designer swaps the two (radio buttons for independent options, checkboxes for exclusive ones), the screen lies about its own rules. Designers make this swap constantly. Stop it.

The checked square makes a quiet promise: this option is independent, and you may select as many of its siblings as you like.

7 presets, 1 selection: push a new radio button in, and the old one pops out. Exactly 1 choice must emerge; that’s the contract the circle signs.

Radio buttons have two quirks worth engineering around. A radio group can’t be deselected once touched, so if abstention is legitimate, add an explicit “None” option. And a group with no default invites accidental non-answers, so preselect the safest or most common choice unless a default would bias a survey response.

The toggle switch is the checkbox’s flashier cousin, popularized by the iPhone in 2007, and the division of labor is clean: use a toggle when the effect is immediate (like a light switch: flip it, and the light responds now); use a checkbox when a submit button commits the choice. A toggle sitting above a Save button is a contradiction: did the setting apply when I flipped it, or when I saved? Nobody knows.

A toggle flips a setting the way a light switch flips a lamp: immediately. If a Save button must confirm the change, use a checkbox instead.

8 design guidelines for checkboxes, radio buttons, and toggles:

1. Use checkboxes for independent options and radio buttons for mutually exclusive sets. The shape is the contract; honor it.

2. Stack options vertically. Horizontal layouts create ambiguity about which label belongs to which control.

3. Make the labels clickable. A 14-pixel circle is a cruel target; the label multiplies the target area for free. (Fitts approves.)

4. Preselect a sensible default in radio groups, and add a “None” option when abstention is valid. Users can’t un-choose a radio group once touched.

5. Phrase options positively. “Send me the newsletter” beats “Don’t exclude me from communications,” and nested negations belong nowhere.

6. Use a toggle only when the setting takes effect instantly. If a submit step follows, it’s a checkbox.

7. Represent a yes/no choice as 1 checkbox, not 2 radio buttons. 1 control, 1 decision, half the reading.

8. Show 2–4 options as visible radio buttons rather than a dropdown. Seeing all choices at once beats an extra click plus a memory test.

9. Tabs: One Row, Same Type, Same Level

Definition: Tabs are parallel panels that share a region of the screen, with a single panel visible and the rest labeled along the edge.

The metaphor comes straight from the file drawer: card dividers with protruding labeled tabs. Tabbed dialogs entered software in the early 1990s, and browser tabs followed in the 2000s (though those belong to window management). In-page tabs suit content of the same type at the same level: a product’s details, reviews, and specs.

The physical metaphor dictates the rules. The selected tab must look attached to its panel, unselected tabs must look clickable but subordinate, labels must stay short, and 1 row is the limit. Microsoft’s mid-1990s options dialogs crammed a dozen tabs into multiple rows, and clicking a back-row tab reshuffled the rows, vaporizing the user’s spatial memory. The industry learned; don’t relearn it at your users’ expense.

The selected tab must look physically connected to its panel, like the open door to a lit room. If users can’t tell which tab is active, the metaphor has collapsed.

Two further misuses recur. Tabs are the wrong pattern for sequential steps: a checkout is a wizard, not a filing cabinet, because steps have an order while tabs promise free movement. And tabs hide content, so if users must compare data across panels, tabs convert recognition back into recall, and your design regresses 40 years in 1 decision. Comparisons want a table.

Tabs mint places. Users think of tabbed content as locations, and places need addresses. That’s the deeper reason every tab deserves a URL: on the web, a place you can’t link to is a place that doesn’t fully exist.

My 7 design guidelines for tabs:

1. Use 1 row of tabs, ever. If they don’t fit, you have too many tabs or too-long labels; fix that instead.

2. Keep labels to 1–2 plain words. Tabs are headings for parallel content, not sentences.

3. Connect the selected tab visually to its panel, and make it distinct from its neighbors. Current, hovered, and unselected tabs must have 3 different appearances.

4. Reserve tabs for content of the same type at the same level. Sequential processes get a wizard with a visible step indicator.

5. Default to the tab most users need first. The first impression of a tabbed area is whatever panel you chose to open.

6. Never split content users must compare across tabs. Flipping back and forth is a memory test; a comparison table is the answer sheet.

7. Give each tab its own URL where the platform allows. Users bookmark, share, and hit Back; a tab that survives those actions behaves like a real place.

10. Search: Users State the Goal in Their Own Words

Definition: The search box is a text field plus a submit action marked by a magnifying glass, letting users state their goal in their own words instead of hunting through navigation.

Many web users have long been search-dominant, heading straight for the box on arrival. For everyone else, search is the escape hatch when the menus fail. Both need a box they can find and an engine that forgives. Google trained the planet in the empty-box idiom, and along the way the magnifying glass became one of the few icons that need no label.

The search box is the one place in your interface where users write to you in their own words. Make it wide enough to hold the whole thought.

Search is the command line that survived. The GUI spent 4 decades replacing typed commands with visible options, yet users still march past all that graphic design to type into a box because language is the one interface that scales to infinite intents. When the space of possible desires outgrows any menu, text wins. The search box is a living fossil, and it’s still evolving: the prompt field in every AI assistant is the same fossil, reborn as computing’s newest paradigm. The interaction alphabet’s most old-fashioned letter may prove its most future-proof.

Search brings a bonus that navigation never will: the query log, where users type their goals verbatim, in their own vocabulary, spelling and all. Your search log is the cheapest user research you’ll ever get. The top queries returning poor results are your to-do list, ranked by demand.

The search box should be wide enough that users can see their entire query; query lengths keep growing, so err on the wide side. Put the box where people expect it: at the top of the page, as an open field, not a hidden icon. Tolerate typos, plurals, and synonyms, because users type “recieve” and mean receive. And treat the results page as a full user interface in its own right (a topic for another day).

Here are 8 design guidelines for search:

1. Show an open search box on every page of a content-rich site, at the top of the page. An icon that hides the box adds a click and subtracts visibility.

2. Make the box at least 27 characters wide. Users must see their whole query to edit it; scrolling inside a text field is misery.

3. Mark the submit with a magnifying glass, and make the Enter key work. Both are conventions users bring with them.

4. Forgive typos, plurals, and synonyms. The engine’s job is to find what users mean, not to grade what they typed.

5. Keep the query in the box on the results page. Reformulation is half of search behavior; make editing a keystroke, not a restart.

6. Design the results page as a full UI. Scannable titles, snippets that reveal why each result matched, and filters once collections grow large.

7. Index everything users consider part of the site. A search that silently skips the support section manufactures false “no results.”

8. Mine the search logs monthly. High-volume queries with poor results are usability bugs filed by your own users, free of charge.

Bonus: The Two Elements That Named the Paradigm

WIMP stands for Windows, Icons, Menus, and Pointer, and as my GUI history recounts, the acronym named the entire paradigm. Icons and menus earned top-10 slots above on daily workload. The remaining two letters now belong mostly to the operating system and the browser, but their rules still bite the designers who forget them.

Windows: You Inherit Yours, So Spawn More Rarely

Definition: A window is a bounded, movable region of the screen that displays an application or document, letting several coexist on 1 display.

Overlapping windows debuted at Xerox PARC in the 1970s, stacking like papers on a desk, and supplied the W in WIMP. Window management has since migrated into the operating system and the browser: a web-app designer inherits the window (the browser tab) rather than designing it. The main surviving design question is when to spawn a new window, and the answer is: rarely. A surprise window breaks the Back button, the web’s reverse gear.

Windows within windows: today’s designer usually inherits the window (a browser tab) rather than drawing it. The remaining job is not to break what you inherited.

Scrollbars are the part of the window designers still touch, since scrolling is the mechanism for viewing content larger than the viewport. The scrollbar is both the control and the map: it shows where you are and how much remains. Users scroll willingly these days, but many studies still show attention piling up at the top of the page, so content order remains a ranking decision. The first screenful carries the argument.

Three scrolling sins recur. Scrolljacking hijacks the speed or direction of the user’s most practiced gesture, a betrayal dressed as delight. Thin or (even worse) invisible scrollbars erase the “how much is left?” signal. And infinite scroll on a page with a footer that users need turns that footer into a mirage: visible, approached, never reached.

Scrollbars must be nice and fat so that users see them and can easily grab the thumb to move it. Microsoft Windows has been an offender with anorexic scrollbars in recent years. Don’t starve the scroll!

Infinite scroll can be a dark design pattern to entice users to doomscroll forever. Even when used ethically, it can make users lose their sense of place and make controls harder to reach.

6 design guidelines for windows and scrolling:

1. Open content in the same window or tab by default. Users who want a new tab know how to get one; don’t decide for them.

2. Never hijack scroll speed or direction. The scroll gesture is muscle memory; overriding it makes the whole page feel possessed.

3. Keep scrollbars visible on every scrollable pane. Hiding the map doesn’t shorten the territory.

4. Use infinite scroll only when nothing users need lives below the list. If a footer matters, use a “Load More” button instead.

5. Order content by importance. Users will scroll, but attention thins with every screenful, so the top is prime real estate.

6. Protect the Back button. Anything that breaks it, including gratuitous new windows, breaks the user’s primary undo for navigation.

Pointers and Cursors: The Hand on the Screen

Definition: The pointer is the on-screen proxy for the user’s hand, and the cursor’s shape signals what a click will do at the current position.

A monument to the pointer: the user’s hand, projected onto the screen. Its shape is a promise about what a click will do. Keep the promise.

The pointer was born with Doug Engelbart’s mouse, built in 1964, demonstrated at the 1968 “Mother of All Demos,” and mainstreamed by the Macintosh in 1984. It supplies the P in WIMP. Its shapes form a sign language: the arrow points, the pointing hand clicks links, the grabbing hand drags, the I-beam edits text. Specialists handle the rest: crosshair, zoom magnifier, color-picking eyedropper, and the spinner that begs for patience.

The drag-and-drop cursor, text selection cursor (I-beam), precision cursor, and the zoom-in (and out) cursor are among the specialized cursor shapes that help users understand what they can do.

Designers rarely draw cursors, but they must respect the signals. A hand cursor over unclickable decoration is a small lie, and an interface can’t afford many small lies. And touchscreens deleted the cursor entirely, taking every hover-dependent cue with it: tooltips, hover menus, hover-revealed controls. If information appears only on hover, everyone on a phone or tablet, which is to say the majority of web traffic, will never see it.

5 design guidelines for pointers and cursors:

1. Use the platform’s standard cursors, and don’t restyle them. A custom cursor is a novelty for the designer and a lie detector test for the user.

2. Show the pointing hand only over genuinely clickable elements, and the I-beam only over editable text. Cursor changes are promises; false ones erode every true one.

3. Show a busy indicator for any wait over 1 second. The cursor’s oldest job is honesty about whether the system heard you.

4. Never make hover the only path to important information or actions. Touch devices have no hover, and neither do keyboards.

5. Give keyboard users a visible focus indicator. The focus outline is the keyboard’s cursor; removing it for aesthetics strands everyone who navigates by the Tab key.

Conclusion: Spell with the Alphabet Users Already Know

The 10 design widgets I’ve analyzed in this article. Learn this alphabet before you invent new letters.

The top 10 GUI design elements (and our two bonus elements) are old, and that’s their credential, not their weakness. Each survived a Darwinian filter of billions of users across 40+ years because each maps onto human constants: recognition over recall, perceived affordance, Fitts’s law, and the finite patience of a person who just wants to buy a plane ticket. So spend your innovation budget on your content and your service, not on breeding a new species of checkbox. Jakob’s Law guarantees the familiar version tests better anyway.

My 86 GUI usability guidelines are specific examples of three underlying UX commandments: don’t make users remember, don’t make users guess, don’t make users wait. Memory, certainty, time: every UI needs a strict budget for imposing on these three resources.

Will the interaction alphabet outlive WIMP itself? My GUI history ends with generative, intent-based interfaces that assemble screens on demand, and my prediction is that the letters will outlast the paradigm: an AI can generate the screen, but a human still has to read it, and humans read buttons, fields, and tabs.

The more generative the interface, the more invariant its controls must become. Dynamic screens weaken spatial memory; familiar widgets restore orientation. Agentic systems raise the stakes further: the old alphabet now carries supervision (approve, pause, inspect, undo) and not merely direct manipulation. AI may compose the interface, but convention makes it governable.

A closing test for your own product: familiar controls disappear into the task, and disappearing is the highest praise an interface element can earn. Which of the 10 does your product misuse the worst? My money’s on alerts if your company is evil, and on menus if it means well.

Even though they’ve been standardized for decades and their usability guidelines are well documented, many modern designs still abuse these GUI elements. (All illustrations in this article were created with GPT Image 2.)

About the Author

Jakob Nielsen, Ph.D., is a usability pioneer with 43 years experience in UX and the Founder of UX Tigers. He founded the discount usability movement for fast and cheap iterative design, including heuristic evaluation and the 10 usability heuristics. He formulated the eponymous Jakob’s Law of the Internet User Experience. Named “the king of usability” by Internet Magazine, “the guru of Web page usability” by The New York Times, and “the next best thing to a true time machine” by USA Today.

Previously, Dr. Nielsen was a Sun Microsystems Distinguished Engineer and a Member of Research Staff at Bell Communications Research, the branch of Bell Labs owned by the Regional Bell Operating Companies. He is the author of 8 books, including the best-selling Designing Web Usability: The Practice of Simplicity (published in 22 languages), the foundational Usability Engineering (31,233 citations in Google Scholar), and the pioneering Hypertext and Hypermedia (published two years before the Web launched).

Dr. Nielsen holds 79 United States patents, mainly on making the Internet easier to use. He received the Lifetime Achievement Award for Human–Computer Interaction Practice from ACM SIGCHI and was named a “Titan of Human Factors” by the Human Factors and Ergonomics Society.

· Subscribe to Jakob’s newsletter to get the full text of new articles emailed to you as soon as they are published.

· Follow Jakob on LinkedIn.

· Read: article about Jakob Nielsen’s career in UX

· Watch: Jakob Nielsen’s first 41 years in UX (8 min. video)

Summary: Comparing GPT 5.6 Sol, Opus 5, Kimi K3 |How designers use a UI design agent | AI enhances users’ agency, and they like it | Breadcrumb navigation | UX Hero Doug Engelbart | The decoy effect in pricing plan comparison pages | The paradox of the Active User | Delhi High Court rules that AI training on copyrighted content is legal in India

UX Roundup for July 27, 2026 (GPT Image 2)

GPT 5.6 Sol vs. Opus 5 vs. Kimi K3

Several high-end AI models were released recently, and as a small comparison test, I asked OpenAI’s GPT 5.6 Sol, Anthropic’s Claude Opus 5, and Chinese Moonshot’s Kimi K3 for suggestions on improving the article on the design primitives for graphical user interfaces I’m publishing on Wednesday. The winner? Kimi K3. Congratulations, Moonshot!

GPT 5.6 Sol (with reasoning level Pro) gave me the most detailed feedback, but it was all overly pedantic in nature and would have substantially lengthened the piece (which was already too long) with small tweaks and elaborations of special cases. Opus 5 (reasoning level Max) wasn’t quite as bad, but still not truly insightful. In contrast, Kimi K3 suggested a new concept that I had not considered myself but which added true value, depth, and a new angle to my article.

For my use cases, Kimi K3 is the best of these new models. However, it still doesn’t reach the depth of insight I’m getting from Claude Fable 5 with reasoning level Max. Fable remains the leading frontier model.

I don’t use AI for software development, and what I hear from AI influencers is that GPT 5.6 Sol is as good as Fable, or possibly better in agentic mode, because of its doggedness. This point is a good reminder that different frontier models can be better for different purposes.

To me, Fable 5 is far superior than Opus 5. This despite the fact that Opus 5 scores equal or better than Fable on the various AI benchmarks. These benchmarks are getting further and further away from representing the business value of AI, at least in domains outside coding and mathematics.

In testing new AI models, Kimi K3 had the most insightful comments on an article draft. But nothing beats Fable 5 for now: it does have that “big model smell.” I look forward to seeing if GPT 6 or Gemini 4 can beat Fable with even bigger models. (GPT Image 2)

I didn’t even bother including Google in this test: it hasn’t updated the top Gemini model since February: hopelessly behind!

210,000 AI Design Prompts: Iteration Lives, but One-Shot Design Still Dominates

Superdesign, the vendor of an AI design agent, has published 26 statistics drawn from 210,759 real prompts that users sent to its tool from January to June 2026. Single-vendor data from a self-selected user base, yes, so don’t mistake these numbers for a census of the design profession. But they’re logs of actual behavior, not a survey of what designers claim to do, and my old rule holds as much for studying design work as for studying web usability: watch what users do, not what they say.

Alice and Zimo explain the new data on how designers use AI to design user interfaces. (GPT Image 2)

The product mix first. Dashboards lead with 13,151 distinct projects, about 1 in 7, trailed by landing pages, pricing pages, and login screens. AI design agents are being fed the workhorse screens of everyday business software, not art projects. Crypto trails the field at 531 projects: a nice measure of the distance between hype and actual work. And when users ask for a company’s style, Linear (229 prompts) now outranks Apple (173). Developer tools set the taste of 2026.

In general, it’s a terrible idea to mirror a famous company’s design. Apple can design the way it does because of who it is. You are not Apple. Same for Amazon: its site moves lots of products, but it’s designed to suit a company with millions of mass-market SKUs, not your (hopefully carefully curated) limited product selection. Remember my 5 D’s: Different demands drive different designs.

The most popular visual request is dark mode, which grew from 26.8% of prompts in January to 38.1% in May. Terminology alert: this “dark mode” is nothing more than the inverted color scheme of light text on mostly black backgrounds. It has no connection to dark design patterns, the deceptive schemes that trick users into unintended actions. Combine dark backgrounds with the most-requested visual device in the corpus (gradients, 61,193 prompts) and the most-requested color (blue, 50,165 prompts), and you get the house style of AI-generated screens in 2026: blue gradients glowing against black. Generic? You betcha, and now we know the statistical recipe.

The behavioral statistics interest me most. 40% of all generations are iterations: 83,349 of them refined an earlier attempt, and one project was reworked 396 times in a single chain. The vendor spins this as proof that people iterate. I read the glass as more than half empty. If 40% are refinements, 60% are opening attempts: roughly 125,000 first drafts shared those 83,349 refinements, or 2/3 of a refinement per draft. My best guess is that the median AI-design project receives zero iterative design.

A one-shot design is a coin flip. Iterative design is much safer and produces better usability. (GPT Image 2)

That’s far too much prompt-and-pray design. One-shotting will never produce the best UX, because a prompt is not intent; it’s merely the user’s first rough attempt at externalizing intent. Humans recognize a good solution far more easily than they can specify one upfront, which is why I’ve argued that creation is becoming exploration and discovery in a latent space of design alternatives, and why AI products must support intent by discovery rather than expect a perfect specification upfront. The person behind that 396-step chain gets it.

The prompt-length numbers are more encouraging. The median prompt runs 806 characters, roughly 130 words: a proper mini-brief rather than a tossed-off sentence. (The mean is 5,949 characters, 7 times the median, because some users dump complete product requirement documents into the prompt field. Good instinct.) UX design is inherently complicated and context-dependent: the right answer varies with the users, their tasks, the brand, the platform, and the business goals. Longer prompts carry more of that context and thus land closer to true intent. 130 words is a decent floor; I’d push it higher.

Credit where due: Superdesign states the basis of every figure, counts projects conservatively (a design iterated 50 times counts once), and publishes both median and mean prompt length. That’s more methodological candor than plenty of peer-reviewed papers deliver. So treat this as a fascinating first window into real-world AI design use, and let’s hope competing vendors release comparable numbers. Meanwhile, apply the lesson in your own projects: write the full brief, then iterate. One shot is a coin toss, not a design process.

The Clearer the Question, the Better the Answer

Clarify the ask. (GPT Image 2)

Reference librarians knew this a century before AI, but prompt-driven UIs raise the stakes: when your question is a maze, the AI dutifully wanders every dead end and hands you the debris. Most “bad AI answers” are bad questions in disguise.

The same principle applies to user research, both for the research questions and for anything you ask your participants. You can (and often should) ask people very open-ended questions, but you still need to be clear about what you’re asking, or you’ll be misunderstood and the answer will be worthless.

Vague in, vague out.

Agency Beats Accuracy: Why People Keep Using AI That Fails Them

People keep using AI chatbots that fail them, sometimes spectacularly, because the felt gain in personal capability outweighs the errors. That’s the headline finding from a new ethnographic study of 51 daily AI users in New York, Berlin, and Singapore, and it should rattle anyone who believes reliability is the road to AI adoption. This felt gain is an agency dividend: users bank it, and it extends AI a generous line of credit for future blunders.

Many heavy AI users like that AI gives them a sense of agency and empowerment, making these users willing to forgive the AI when it makes mistakes. (GPT Image 2)

The study, “AI Usage Patterns Are Shaped by Perceived Gains in Human Agency”, comes from Ian Beacock and colleagues at Jigsaw (Google’s technology-and-society unit) and the research consultancy Gemic; a companion essay on Medium gives the short version. Fieldwork ran April–July 2025. Ethnography is slooow, expensive, and unfashionable in the era of million-conversation log studies. It’s also the closest a research method gets to my old command: watch users, not demos.

The team collected video diaries of memorable AI moments, ran 120-minute interviews in participants’ homes and offices, and added a clever twist: dyad interviews with a friend or family member present, exposing gaps between what users claim and what the people around them observe. The analysis yielded 315 coded observations. A whopping 40 of the 51 participants defaulted to ChatGPT.

Agency Benefits Users in 5 Ways

Participants consistently credited cumulative AI use with expanding their agency, meaning their ability to shape their own lives. And not vaguely: the researchers sorted the perceived gains into 5 dimensions.

Many participants tied these feelings to concrete payoffs. A Singaporean office worker attributed her raise, and her male colleagues’ newfound respect, to AI-polished communication. A German flight attendant credited AI with carrying her across the skills gap to become a DJ. One American business owner estimated that cumulative AI use had lifted her from 60% to 80% of her human potential. (Her own estimate; nobody measured anything. But the conviction is the point.)

Errors Forgiven, Not Even Counted

Now the finding with teeth. That same business owner watched her chatbot promise to build an investor presentation, confirm progress repeatedly, and then fail 10 hours before the meeting, forcing her to build the deck herself. Did she quit the tool? No. One botched deliverable weighed little against the accumulated dividend. Likewise, a medical student caught his chatbot hallucinating a key investment figure; when he demanded accountability, the bot replied with a fire emoji. (Nice work, robot.) His verdict: “Trust can’t be broken because I never had it in the first place.” A German lawyer in the study observed that AI presents wrong answers so believably that she often can’t tell truth from confabulation. She uses it daily anyway, for legal translation no less.

Agency is such a powerful feeling that users forgive much. (Muse Image)

Thus the paper’s theoretical punch. The trust frameworks HCI has leaned on since Bonnie Muir’s foundational work in 1987–1994 assume that trust accumulates stepwise through reliable performance and is forfeited through failure, just as a credit score does. Conversational AI ignores that script. Usage surges immediately, and users then run a rough risk calculus; one salesman stated it plainly: a small chance of error, times a low impact if it’s wrong, is worth taking. The locus of judgment has flipped: users aren’t evaluating the machine (“Is it reliable?”) but themselves (“Am I more capable with it?”). That inversion explains adoption curves that reliability metrics never will.

But the dividend isn’t paid out evenly. Participants living unstable lives (precarious work, thin support networks, fresh grief) used AI most expansively, across their most sensitive problems, and reported the largest gains; one relied on her chatbot for a panoply of roles: personal trainer, nutritionist, advisor, and “big sister.” Participants with stable, well-supported lives kept AI in a narrow instrumental lane and felt little change in their overall potential. Self-confidence mattered just as much. Users with shaky internal conviction spiraled, like the woman stuck endlessly re-revising AI email drafts because she assumed the machine’s output must beat anything she could write. Confident users bailed out of failure loops fast and switched tools without drama.

Hope springs eternal, but confident users exercise agency over their AI and break out of loops of failed sessions that go nowhere. (GPT Image 2)

In fact, these heavy users were no cheerleaders. Most were skeptical about AI’s societal impact, and even people who felt personally supercharged reported zero sense of power over where the technology itself is heading. Personal agency rose; structural agency stayed flat.

The Caveats, Briskly

The usual ethnographic limits apply: 51 self-selected heavy users, self-reported perceptions, no measures of actual skill or outcomes, a snapshot from spring 2025 before agentic AI spread, and Google money behind the research. Perceived agency isn’t material agency; nobody verified the reversed prediabetes one participant credited to her chatbot. To the authors’ credit, they say all of this themselves, and they flag the sobering possibility that AI delivers a short-term psychological boost while quietly eroding long-term capability. Several participants voiced that fear unprompted; one called his urge to outsource simple arithmetic “getting dumb.” Still, the core behavioral finding (errors don’t dent usage) matches what every AI product’s retention curve already shows. The ethnography explains why, which logfiles never can.

Design Implications: Don’t Ship Empowerment Theater

What should you change after reading this study? 5 things:

1. Stop treating reliability as a retention strategy. Fix hallucinations because they waste users’ time and poison downstream work, not because users will churn over them. They won’t.

2. Beware the sycophancy shortcut. If felt capability drives usage, the cheapest way to boost it is flattery: one musician loved that her AI kept “reminding me of all the good things that I possess.” An AI that manufactures the feeling of agency without the substance is empowerment theater, and optimizing for it is a dark pattern.

3. Design for capability transfer. Explain reasoning, teach while doing, and leave the user more able when the AI is off. The benchmark that matters is whether he or she is more skilled after 6 months, not happier in session 12.

4. Detect and break failure loops. When a user has thrashed through several revisions of the same output, offer an off-ramp: restate the goal, start fresh, or ship the human’s own draft. Low-confidence users need this most and will request it least.

5. Treat low-stability users as a vulnerable population. People leaning on AI for medical, financial, and relationship decisions are precisely those with the fewest backstops when it fails. High-stakes domains need guardrails and referrals; disclaimers won’t cut it.

Users treat AI the way venture capitalists treat startups: they expect duds and stay for the outsized returns. So give them returns worth staying for. Durable capability compounds; the warm glow of a fire emoji does not.

Breadcrumb Navigation: 1 Line of Screen Space, 0 Downsides

The one line that answers “where am I?”

Definition: Breadcrumb navigation is a horizontal row of links, placed directly above the page title, showing the current page’s position in the site hierarchy, with 1 link per ancestor level.

Example: An armchair page on a furniture site shows: Home > Living Room > Chairs > Armchairs. Every crumb is clickable except the last, which names the current page.

That’s the whole pattern. One line. No JavaScript heroics required.

The breadcrumb trail marks the route through the site hierarchy: Home > Products > Category > Details. Unlike Hansel’s original, birds can’t eat it. (GPT Image 2)

Named After a Fairy-Tale Failure

The term comes from Hansel and Gretel, published by the Brothers Grimm in 1812: Hansel drops a trail of breadcrumbs through the forest so the children can retrace their steps home. (In the story, the scheme fails as birds eat the crumbs, and the kids end up at a witch’s house. Web breadcrumbs are more durable and less likely to get your users cooked.)

Hypertext systems tried trail markers before the web; the pattern spread during the directory-happy 1990s. In 2002, information architect Keith Instone sorted the variants into three types: location (position in the hierarchy), path (the route this particular visitor took), and attribute (facets describing the item, common in e-commerce).

But my verdict hasn’t budged in a quarter century: location wins. Path breadcrumbs duplicate the Back button, only less reliably, because the browser remembers history better than your session logic ever will. Users need a map, not a diary.

Deep Links Demand Breadcrumbs

Search engines, not your homepage, are your site’s front door. A visitor who lands 4 levels deep from a Google result arrives with zero context: he or she has no idea what else you offer or how it’s organized. Breadcrumbs repair that at a glance and invite the visitor to climb one level instead of bouncing back to the search results. Three further benefits:

• Zero downside. Users who don’t need the trail simply ignore it. In testing, I’ve seen breadcrumbs overlooked, glanced at, and gratefully clicked, but never misunderstood.

• Cheap orientation. One modest line encodes the page’s full ancestry. Compare that to the screen real estate a mega-menu devours. No contest.

• Free search visibility. Google parses breadcrumb markup and displays the hierarchy in its results. So the trail starts working before anyone reaches your site.

5 Ways to Botch the Trail

Do breadcrumbs replace the main navigation? No. And designs that forget this turn a helpful pattern into a harmful one:

• Promoting the trail to primary navigation. Breadcrumbs expose ancestors only; no siblings, no other sections. Users still need the menu.

• Showing the visitor’s click history. Path-based trails differ on every visit and contradict the site structure. Confusion, guaranteed.

• Linking the current page. Clicking the last crumb reloads the page: a small betrayal that erodes trust in the whole trail.

• Breadcrumbing flat sites. With 1 or 2 levels, the trail merely restates the menu. Digital detritus; cut it.

• Crumb creep. Each taxonomy redesign adds a level until the trail wraps to 2 lines and stops being glanceable. Prune the hierarchy or truncate middle levels.

7 Guidelines for Breadcrumb Design

1. Show the page’s location in the site structure. Location trails stay identical across visits, and that stability is what makes them learnable.

2. Begin with Home, and link it. The trail should always offer an exit to the top level.

3. End with the current page, unlinked. It confirms position without pretending to be an action.

4. Separate levels with “>”. Users parse this convention instantly; cleverness here buys nothing.

5. Place the trail directly above the page title. That’s where people have learned to look.

6. Style it as a supporting actor. Small text and modest contrast keep it visible when needed and ignorable when not.

7. Keep crumbs tappable on mobile. Preserve touch-target size even if you must truncate middle levels.

Hansel’s breadcrumbs failed him; yours won’t, because pixels outlast pastry. Open your deepest page in a private browser window and pretend you arrived from Google. If you can’t tell where you are within 5 seconds, you know what to build this week: one line of markup. Leave the trail.

UX Hero Doug Engelbart

Douglas Engelbart is my hero, big time. He was one of the main pioneers of the graphical user interface. He was also a true gentleman: both in the literal sense of being a gentle, soft-spoken man, and in the normal sense of the word. He never bragged about his accomplishments and was kind enough to let me try out the world’s first computer mouse when he brought it to a meeting. (His wooden contraption was heavy, but that humble prototype begat billions of nimble descendants. Fitting for a device named after a rodent.)

Even one of Engelbart’s inventions would have been enough to ensure him a place in history. (GPT Image 2)

Ask anybody what Doug Engelbart did, and you’ll hear: “He invented the mouse.” True enough. The first prototype was a wooden block riding on 2 perpendicular metal wheels, built at Stanford Research Institute in 1964. On December 9, 1968, Engelbart staged what we now call the “Mother of All Demos” (YouTube): 90 minutes showcasing the mouse, hypertext, multiple windows, videoconferencing, and collaborative editing, more than 15 years before the Macintosh shipped in January 1984. (SRI later licensed the mouse patent to Apple for roughly $40,000. Engelbart never saw a dime in royalties.) I recount his pivotal role in my article on the history of graphical user interfaces.

But celebrating Engelbart for the mouse is like celebrating Gutenberg for metallurgy. The gadget served a mission he had spelled out in his 1962 report, Augmenting Human Intellect: A Conceptual Framework: computers shouldn’t replace human thinking but amplify it, raising what he called humanity’s “collective IQ.” His lab at SRI was named the Augmentation Research Center, and no name in computing history has been more honest. Engelbart’s Augmentation effort remains the founding charter of user experience: technology exists to expand what people can do.

For 60 years, we delivered the small half of his vision (point, click, drag) while the big half languished. AI changes that. I’ve recently argued for upgrading Engelbart’s goal from augmenting the human intellect to augmenting the human existence: AI takes over the intellectual chores, freeing humans to exercise judgment, creativity, and intent. The mouse let us tell computers where. AI lets us tell them what.

Engelbart died in 2013, having watched his pointing device conquer every desktop while his deeper dream waited. Finishing that job falls to us. Get augmenting.

The Decoy Effect: An Option Nobody Picks Can Shift Half Your Buyers

Add a third option that’s clearly worse than one alternative (but not worse than the other on every count), and buyers flock toward the alternative that dominates it. In the classic demonstration, a decoy nobody chose moved the premium option’s share from 32% to 84%. The effect is real, fragile outside the lab, and just one step from being dark design.

The middle plan glows partly because the plan beside it was engineered to make it glow. A pricing page is a comparison machine, and somebody chose the comparisons. (GPT Image 2)

A Crack in Rational Choice, Found in 1982

Classical choice theory includes an axiom called regularity: adding an option to a choice set can’t increase the probability of picking an existing option. In 1982, Joel Huber, John Payne, and Christopher Puto published Adding Asymmetrically Dominated Alternatives in the Journal of Consumer Research and broke that axiom across 6 product categories (cars, restaurants, beer, lotteries, film, and TV sets).

Definition: A decoy is an option that is asymmetrically dominated: inferior to one alternative (the target) on every attribute, but inferior to the other alternative (the competitor) on only some attributes. Adding the decoy increases the target’s share. The phenomenon is AKA the attraction effect or the asymmetric dominance effect, but the popular name comes straight from the duck hunter’s toolkit: a decoy isn’t there to be chosen; it’s there to attract.

Real duck decoys work. Similarly, web decoys can sometimes boost persuasive design. (Muse Image)

The Economist’s Famous 3 Subscriptions

Behavioral economist Dan Ariely turned the effect into a legend in his 2008 book Predictably Irrational, using The Economist’s then-current subscription page: web-only for $59, print-only for $125, and print-plus-web for the same $125. He tested the lineup on 100 MIT students. With all three options on the table, 16% chose web-only, 0% chose print-only, and 84% chose print-plus-web. Remove the print-only plan that literally nobody wanted, and the numbers inverted: 68% web-only, 32% print-plus-web.

Walk through what that means. An option with 0% share swung the expensive plan from 32% to 84%, a shift of 52 percentage points. The print-only plan functioned as a lens ground to make $125 look like a bargain when placed next to itself-plus-a-free-website.

Fragile in the Wild

Before you rebuild your pricing page tonight, a cold shower. Shane Frederick, Leonard Lee, and Ernest Baskin argued in The Limits of Attraction (Journal of Marketing Research, 2014) that the effect lives mostly in stylized lab choices where every attribute is a number, and weakens or vanishes with real, perceptually experienced products. Sybil Yang and Michael Lynn ran 91 attempts across 23 product classes and obtained only 11 reliable effects. Huber, Payne, and Puto fired back that the failed replications had violated the effect’s known preconditions, and the fight continues in the journals.

My reading of the evidence: the decoy effect is a tiger in the lab and a house cat in the field. It shows up most reliably when options are few, attributes are numeric and comparable, and buyers hold weak prior preferences. Conveniently, that describes a 3-column SaaS pricing page rather well. But nobody should deploy a decoy on faith. Test on your own users with real transactions, and measure downstream (refunds, cancellations, support tickets) rather than just the click. That, by the way, is the general recipe for applying behavioral economics to UX: treat lab effects as hypotheses to test on your users, never as laws to install.

Zombie Tiers Are Bait, and Users Eventually Smell Them

Which brings us to ethics, and to usability. Context has an honest use: arranging genuinely useful options so their real differences are easy to compare, letting the best value for most people be visibly the best value. Fine. The dishonest use is manufacturing a zombie tier: a plan with no intended buyers, kept shambling around the pricing page purely to flatter its neighbor.

Zombie tiers hurt in three ways. They add cognitive load, since every fake option is one more column users must parse, and choice overload punishes hard enough with honest options. They corrode trust: users who spot the trick (and increasing numbers do) re-evaluate everything else you told them. And they invite regulators, because manipulative choice architecture sits squarely in the crosshairs of the FTC’s dark-patterns enforcement, as I discussed when analyzing the FTC’s lawsuit against Amazon. Short-term conversion, long-term subpoena. (A slight exaggeration. But only slight.)

The remedy is a standing audit: when a tier’s share rounds to 0% and its only measurable function is contrast, either give it a genuine audience or kill it.

6 Design Guidelines for Honest Choice Sets

1. Give every option a genuine buyer. If you can’t name the customer a tier serves, the tier is bait.

2. Cap the lineup at 3–4 options. Beyond that, comparison collapses and users defect to “decide later,” the worst outcome of all.

3. Badge honestly. “Most popular” must be statistically true; a manufactured highlight is a decoy in a party hat.

4. Keep comparisons symmetric and scannable. Same attributes, same units, aligned rows; asymmetric tables are where decoys hide.

5. Test with real transactions and downstream metrics. Lab preferences overstate the effect; refunds and churn reveal whether you persuaded or tricked.

6. Audit for zombie tiers quarterly. Near-0% share plus a contrast-only function equals redesign or removal.

Users rarely know what anything is worth in absolute terms; they know what it’s worth next to its neighbors. Treat that as a constraint to respect rather than a flaw to exploit, because whoever designs the choice set designs a large share of the choice. Arrange your comparisons as if the user could watch you do it. Sooner or later, he or she can.

The Paradox of the Active User: Nobody Reads the Manual, and Nobody Ever Will

Users plunge into real tasks without reading instructions (production bias) and interpret every new system through old habits (assimilation bias). Both behaviors are locally rational and permanently immovable, so design for the plunge: safe exploration, help at the point of need, and conventions people already know.

Users jump straight into action, skipping any upfront instructional steps. Read the manual? Forget it! Carroll and Rosson called it a paradox in 1987; today, all designers should assume that manuals mainly go unread.

Definition: The paradox of the active user is the finding that people are so motivated to produce real work that they skip the very learning that would make them faster at producing it.

The documentation center has a banner exhorting the user to “read the docs” because “future you will thank you.” This may be true, but users don’t comply. (GPT Image 2)

Two biases drive the paradox. Production bias: time spent learning feels like time stolen from the task, so users dive in and never look back. Assimilation bias: users interpret the new system as if it were the old one, importing habits that no longer fit. Each choice is sensible in the moment (deadlines are real, and prior knowledge usually does help), which is exactly what makes the pattern permanent. But the lifetime cost is steep: as the original authors put it, users’ skill “tends to asymptote at relative mediocrity.” People plateau at good enough, forever.

Production bias: people just want to do the task, not learn. (GPT Image 2)

IBM, 1987: Watching People Not Read

John M. Carroll and Mary Beth Rosson of IBM’s Watson Research Center published “Paradox of the Active User” (32-page PDF) as a chapter in Interfacing Thought (MIT Press, 1987). Their studies of office workers learning word processors kept producing the same footage: manuals pushed aside, tutorial exercises skipped, real letters attempted in minute one, and every error interpreted through typewriter habits. The chapter’s heretical move was to declare these behaviors permanent facts of human motivation to design around, rather than user defects to train away.

Much early UX research studied people using word processors. Users wanted to type, not read instructions. (GPT Image 2)

(Jack Carroll was my boss when I worked at IBM and a genuine hero of user experience, with many more fundamental insights to his credit than the paradox he and Mary Beth named.)

And Carroll had already built the design response. His 1984 “Training Wheels in a User Interface” study with Caroline Carrithers (Communications of the ACM) blocked a word processor’s advanced functions for beginners: 4 of 6 training-wheels learners completed a letter-writing task versus 2 of 6 on the full system, in 92 versus 116 minutes. He then spent a decade developing minimalist instruction, summarized in The Nurnberg Funnel (MIT Press, 1990), named for the legendary funnel that pours knowledge straight into a student’s head. No such funnel exists. That’s the point of the title.

A training wheels approach makes the initial experience easier by providing a simplified UI in the beginning. (GPT Image 2)

The Nurnberg funnel poured information straight into the user’s brain. Unfortunately, it’s not real. (GPT Image 2)

Design for the Plunge

Accepting the paradox produces a plunge-first design philosophy: build every product on the assumption that the user’s first act is to attempt a real task. The consequences read like a usability greatest-hits list, which is no coincidence, since several of my 10 usability heuristics exist to serve exactly these two biases.

Production bias means the first task is the only tutorial users will ever attend, so it must succeed unaided: strong defaults, templates instead of blank canvases, recognition rather than recall, and undo everywhere so that exploration stays safe. Error messages become the de facto documentation; write them to teach. (My 1997 research with John Morkes at Sun Microsystems on how people read on the Web found most users scanning rather than reading. Imagine the enthusiasm for your PDF quick-start guide.)

Attempting the first task (here, pulling the lever to get a fish) is the one thing you can count on users to do, so that has to become the learning experience. (GPT Image 2)

Assimilation bias, meanwhile, is the engine behind Jakob’s Law: users spend most of their time on other sites and expect yours to work the same way. You don’t get to choose whether users import habits; you only choose whether the imports find a match. So follow platform and web conventions first, and deviate only where your data shows the deviation earns back its retraining cost.

Complying with design conventions makes everything easier, including the initial experience, since users can transfer their learning from other sites they’ve already used. (GPT Image 2)

Two Ways to Get It Wrong

Denial is the popular failure. Teams ship complexity and point at the help center; they front-load an 8-step tooltip tour that production bias dismisses in 3 seconds; support staff mutter about users who won’t read. (The manual has been losing this fight since 1987, against typewriter-trained office workers. Your users have less patience and better distractions.) The cure is to relocate instruction into the task: one sentence, in context, at the moment of need, plus a first run that reaches success within minutes.

Design for the world the way it is, not the way you wish it were. Denial won’t work. Accept that most users won’t read your instructions. (GPT Image 2)

Surrender is the sophisticated failure. Citing “users don’t read,” teams delete all guidance, and power features rot undiscovered while everyone plateaus at that relative mediocrity, now upgraded from user behavior to design choice. The fix here is teaching inside the workflow: show the keyboard shortcut beside the menu command it accelerates, suggest the 1-step path right after the user completes the 5-step one, and keep reference documentation for the two moments people genuinely read: total breakdown and specific lookup.

7 Design Guidelines for Plunge-First Users

1. Make the first real task succeed unaided. Within minutes, with defaults and templates carrying the load. This is the only onboarding users will attend.

2. Undo everything. Exploration is how active users learn, and it’s only rational when mistakes are recoverable. An unrecoverable action ends the lesson.

3. Replace the tour with the task. A guided first task teaches more than 8 tooltips, because it produces something, and production is the one motivation you can bank on.

4. Follow convention first. Meet the habits users import from the rest of their software life, and deviate only where testing proves your way measurably better.

5. Ship expert defaults. Most users never change settings, so the defaults are the product. Encode best practice in them.

6. Teach at the moment of need. One sentence, in context, when he or she hits the situation it explains. The shortcut belongs beside the command, since that’s the only classroom with attendance.

7. Write documentation for the two moments users read. Breakdown and lookup: task-titled pages, searchable, answer-first. Everything else in the docs is a museum.

Since users want to interact with your UI, encourage them to explore it by making it very easy to recover from mistakes. Undo is mandatory. (GPT Image 2)

AI Training Is Fair Use in India

The Delhi High Court found that OpenAI’s use of news agency ANI content for model training was protected by India’s research-oriented fair-dealing exemption. The court said ANI had not demonstrated that ChatGPT memorized or reproduced its reports.

The Delhi High Court rules that AI model training is fair use as long as it does not reproduce the source materials. (GPT Image 2)

In this case, I agree with the court: learning from existing content should be fair use, not copyright infringement. That’s how humans have learned since the first campfire story. In fact, there’s an argument to be made that the reason Homo sapiens was able to exterminate all the competing hominin species is our superior ability to learn from other humans, not any unmatched talent for original thought.

In other words, it’s fair to learn from Disney that funny animals are great for storytelling. But don’t use their IP, which should indeed remain protected by copyright, though for fewer years than current law grants. It’s now legal to draw very early versions of Mickey Mouse, but I’d rather stay away from existing characters and invent my own.

Animal characters are great, but invent your own. That’s much more fun than stealing others’ copyrighted IP. (GPT Image 2)

While I prefer creating original characters, copyright protection does need a time limit, and the current US time limit of 95 years is too long. 50 years should be more than enough to allow creators to recover their investment. (GPT Image 2)

Conclusion: New Tools, Same Humans

One thread stitches this week’s items together: every 2026 finding was foreshadowed decades ago. Carroll and Rosson filmed office workers plunging into word processors without reading a page in 1987. Superdesign’s logs catch designers doing the same thing to AI in 2026, where the median design project gets zero iteration. Production bias didn’t retire; it moved from the typewriter to the prompt box. Ask a vague question in 1926 or 2026, and you get debris back either way.

Old word processors or modern tech? Doesn’t matter for UX insights; humans are the same. (Muse Image)

The agency study reads like Engelbart’s 1962 report returning as field data. He promised computers that amplify human capability; 64 years later, 51 users in 3 cities describe exactly that feeling, and they reward it so richly that they forgive the machine’s blunders. But the same psychology that banks an agency dividend also falls for a decoy or a flattering chatbot, which is why zombie tiers and empowerment theater deserve adjoining cells. Even the Delhi High Court leaned on the oldest constant of all: learning from others is how intelligence has always scaled, whether the student is a hominin or a model.

So here’s the state of affairs in mid-2026: the technology is sprinting, and the humans are standing still. Hansel’s trail still orients us. Huber’s decoys still tug at us. Carroll’s plungers still skip the manual, now in 806-character prompts. Human behavior is the one legacy system nobody gets to refactor. AI changes what computers can do, not what people do. Design for the constant, and you’ll profit from the variable.

Annoying as it often is for designers, we can’t change human nature. We were biologically optimized by evolution for survival in the ancestral environment, not optimized for computer use. (Muse Image)

A Final Thought

If you know, you know … why the card reads “32nd anniversary.” (GPT Image 2)

About the Author

Jakob Nielsen, Ph.D., is a usability pioneer with 43 years experience in UX and the Founder of UX Tigers. He founded the discount usability movement for fast and cheap iterative design, including heuristic evaluation and the 10 usability heuristics. He formulated the eponymous Jakob’s Law of the Internet User Experience. Named “the king of usability” by Internet Magazine, “the guru of Web page usability” by The New York Times, and “the next best thing to a true time machine” by USA Today.

Previously, Dr. Nielsen was a Sun Microsystems Distinguished Engineer and a Member of Research Staff at Bell Communications Research, the branch of Bell Labs owned by the Regional Bell Operating Companies. He is the author of 8 books, including the best-selling Designing Web Usability: The Practice of Simplicity (published in 22 languages), the foundational Usability Engineering (31,192 citations in Google Scholar), and the pioneering Hypertext and Hypermedia (published two years before the Web launched).

Dr. Nielsen holds 79 United States patents, mainly on making the Internet easier to use. He received the Lifetime Achievement Award for Human–Computer Interaction Practice from ACM SIGCHI and was named a “Titan of Human Factors” by the Human Factors and Ergonomics Society.

· Subscribe to Jakob’s newsletter to get the full text of new articles emailed to you as soon as they are published.

· Follow Jakob on LinkedIn.

· Read: article about Jakob Nielsen’s career in UX

· Watch: Jakob Nielsen’s first 41 years in UX (8 min. video)

Summary: Carousels are scanned in an L-pattern, not the F-pattern | Making AI-Native games playable | Bulk actions support flexibility and efficiency of use | AI film wins a bronze lion at the Cannes Festival | Users remember the peak experience and the end | Use of AI applications doubled in one year

UX Roundup for July 24, 2026 (GPT Image 2)

Carousels Break the F-Pattern: Users Scan in an L and Ignore Your Labels

Eye tracking of 87 users browsing streaming-style screens refutes every web-search assumption it tested: no F-pattern, no hierarchical label-first browsing, no examination hypothesis. Users judge each row by its first thumbnails, swipe only when committed, and read carousel titles late or never. Design for that behavior, or don’t use carousels at all.

Definition: A carousel is a horizontally swipeable row of themed items sitting beneath a descriptive label; only the first few items are visible until the user swipes. Stack such rows vertically, and you get a stacked carousel interface.

Example: The Netflix home screen: rows labeled “Trending Now,” “Comedies,” or “Because You Watched…” each show 5–6 movie posters, and an arrow slides in more titles from the right. (Not the auto-rotating homepage hero rotator; that one remains a stinker.)

The stacked carousel interface has multiple rows of rotating items on top of each other. Lots of opportunity for users to spin. (GPT Image 2)

In a new study presented at SIGIR 2026, Jingwei Kang, Maarten de Rijke, and Harrie Oosterhuis of the University of Amsterdam tested whether the assumptions baked into carousel click models and metrics match real behavior. They analyzed RecGaze, the only public eye-tracking dataset for stacked carousel interfaces, collected by Santiago de Leon-Martinez and colleagues: 87 participants each browsed 30 streaming-style screens and clicked the one movie they’d watch per screen, for 2,375 valid screens. Each screen stacked 10 genre rows of 15 movies, shown 5 at a time across 3 swipeable viewport sets.

The team checked 4 assumptions imported from web search: the F-pattern; hierarchical, left-to-right browsing; the examination hypothesis (clicks hinge only on an item being seen and being attractive); and title-first navigation. None survived. My gripes: 1 dataset, 1 layout, 1 leisure domain, a forced click per screen; the authors concede them all. Still, 1 real dataset beats 10 borrowed assumptions.

Scanning a Carousel Is Nothing Like Scanning a Page

When I named the F-pattern in 2006, our eye-tracking data showed fixations hugging the top-left corner of text-heavy web pages, thinning rightward and downward. Carousels bend that geometry 3 ways:

• Dual focus on the initially viewable set. Attention peaks top-left as expected, but a second peak appears at the top-right (partly swipe-arrow hunting, perhaps, though the authors doubt it).

• Mirrored Fs after swiping. On the second and third viewable sets (after swiping), attention decays right to left: swiped-in content enters from the right.

• No F across viewport sets. Examination falls off a cliff at the viewport boundary: in the top row, 84% saw the last visible movie but only 33% saw the first hidden one.

Conditioned on a click, a new shape emerges, which the authors dub the L-pattern: users examined the entire first item of nearly every row above the click, plus the clicked row out to the clicked item. And swiping happens almost exclusively in the row that wins the click. Horizontal exploration isn’t browsing; it’s commitment.

Row titles fare worst. The top row’s first thumbnail was examined on 91% of screens; its title on only 26%, so a whopping 65% of users (at minimum) saw the movie but never its genre label. In fact, titles were the first element examined in a row a mere 2–15% of the time. We’ve long known about banner blindness on web pages: users skip anything shaped like an ad. Carousels instead exhibit label blindness: users look straight past the heading to the pictures beneath. The thumbnails are the navigation; the title is decoration (not the other way around, as you might have surmised, given that thumbnails are just pretty pictures — but they do define the movie and usually show the lead star).

The examination hypothesis fell too: with row order randomized, click rates given examination should match within any column. They didn’t: row 1 out-converted row 6 by 2.63 percentage points (p < 0.001), a cousin of the trust bias in ranked lists.

Why Carousels Rewire the Eyes

Why does a pattern that held for 20 years of web pages collapse in a carousel? Four reasons:

1. Swiping moves the starting line. The F was never about the letter; it described economical scanning that begins where content begins. Carousel rotation relocates that origin to the right edge, so the F mirrors.

2. Interaction cost gates exploration. Off-viewport items must be paid for with a click to rotate the viewport, so users dig horizontally only after deciding a row deserves it. Hence the L.

3. Pictures out-shout words. 5 scary movie posters say “thriller” faster than the word Thriller; the items carry the information scent. Recognition beats reading.

4. The first column is a free sampling menu. Cruising down the leftmost thumbnails samples every category with minimal eye travel. Users shop the carousel like a supermarket: judge each aisle by its endcap, ignore the ceiling signs, and walk down only the aisle holding tonight’s dinner.

6 Guidelines for Stacked Carousel Design

1. Lead each row with its 2 most category-defining items. Users infer what a row is from its opening thumbnails, not its title; those slots must communicate the theme, even if that demotes the most popular item.

2. Ration your rows. First-item examination fell from 91% in row 1 to 39% in row 10, so strategic categories belong in the top 3–4 rows.

3. Treat off-viewport items as invisible. Given the cliff at the viewport boundary, content that users must see belongs on the initially visible set (shown without rotating the carousel). No exceptions.

4. Never confine essential information to a title. Disclosures like “Sponsored” and urgency cues like “Leaving Soon” must sit on the items, because most users skip the label, and the rest read it late.

5. Log swipes as high-intent signals. Users swipe almost only in the row they end up choosing, so an arrow click is a shortlisting act. Feed it to your personalization model.

6. Fix your metrics. Position discounts that decay smoothly from the top-left reward the wrong placements. Weight the initially viewable set and the first column heavily, expect near-zero exposure elsewhere, and remember trust bias inflates top-row clicks.

When to Use a Carousel, If Ever

Use a carousel only when 3 conditions all hold:

• Items are visually self-describing: posters, products, photos, artwork. If your thumbnails are logos or gray document icons, the rows say nothing.

• Many categories must share one viewport, and cross-category sampling genuinely helps, as in entertainment and shopping discovery.

• The task is open-ended browsing. For lookup and directed tasks, search plus a vertical list wins; nobody should paginate horizontally toward a known target.

Fail any test, and a plain list or grid serves users better, because a carousel hides 2/3 of each row behind swipes that only the already-committed will make. My recommendation: streaming services, recipe collections, and e-commerce discovery have earned carousels; documentation, B2B catalogs, and dashboards haven’t.

Carousels are supermarket shelving for pixels: fine for a leisurely cruise past visually appetizing goods, wrong for finding the fuse box. The Amsterdam team swapped 4 borrowed assumptions for observed behavior; designers must now do their part. Respect the L, stock the endcaps, and stop expecting anyone to read the aisle signs.

AI Autocomplete: A Serious Attack on the Articulation Barrier

MagicX released AI Autocomplete this week: it turns an ordinary text box from a passive receptacle into an active guide. Conventional autocomplete predicts the next word or a popular query. MagicX instead predicts the action a person wants and reveals the missing parameters required to perform it. The feature is designed to sit inside search, commerce, media-generation, agent, and customer-service products. The host product still executes the action.

Regular autocomplete simply adds more letters and words to the user’s input. This can save a lot of typing and is a useful, if unintelligent, feature. (GPT Image 2)

As an example, if a shopper types “Buy,” AI Autocomplete can offer category, color, brand, model, budget, delivery, size, and payment choices. Suggestions appear as pills and dropdowns; selections become both a readable query and structured fields. Suggestions may draw upon a product’s catalog, inventory, prices, metadata, rules, and business logic. Users can ignore the suggestions or submit an incomplete request, as before.

The important UX contribution is that AI Autocomplete directly attacks the articulation barrier I described in 2023. Intent-based AI is powerful because users state the desired outcome instead of operating every control. Its price is the demand that people accurately describe their needs in prose. Writing new prose is harder than recognizing or reading existing material, and even highly literate users routinely fail to specify complex needs completely. I therefore predicted that successful AI interfaces would be hybrids: natural language for flexibility, supplemented by GUI elements that show users what the system can do.

The articulation barrier: Users cannot ask what they cannot yet articulate. (GPT Image 2)

Intelligent autocomplete is predictive of the user’s intent. If it’s good, it can describe what you want better than you could articulate it yourself. Does MagicX’s new product fulfill this vision? We don’t know yet. (GPT Image 2)

MagicX is an unusually faithful implementation of my prediction, at least if it works as promised. Users can begin with a crude fragment and progressively recognize suitable options instead of recalling product capabilities, specialist vocabulary, and every necessary constraint. This should reduce typing, expose otherwise invisible features, prevent some invalid requests, and replace several rounds of clarification with one richer submission. In my later article on prompt augmentation, I predicted real-time inline assistance while the user writes the prompt. MagicX combines two of my AI design patterns (Prompt Builders and Parametrization) inside the text field itself.

For bounded tasks with a well-understood structure, this could lower the articulation barrier substantially. Buying shoes, booking travel, filtering a catalog, configuring media generation, or briefing an agent all contain dimensions that can be anticipated and presented as choices. The user need not become a prompt engineer merely to remember that price, delivery date, camera angle, authentication, or visual style matters.

Understanding user intent matters, and good AI can do this better, though not perfectly. If the user types the three letters K-E-Y, what do you predict as good autocompletes? If you can infer that the user’s intent relates to the object used to unlock a lock, then you could suggest keychain, keyholder, and simply “keys.” Without correct intent inference, good old stupid autocomplete would happily suggest words like keyboard and keynote. (GPT Image 2)

However, lowering the barrier is not eliminating it. Users must still initiate the request, read the labels, and recognize the correct options. The feature supplies only dimensions anticipated by the product’s schema and business logic. If an important constraint is absent, it remains invisible. Suggestions may also anchor people on plausible but incomplete interpretations. AI autocomplete could also become Dark Design by unduly promoting choices favored by the seller.

Most importantly, people often cannot articulate complex needs because they do not yet know what they want. They discover their intent by seeing alternatives, reacting to results, and revising the problem. Autocomplete front-loads known parameters; it doesn’t perform deep requirements discovery. This leaves it short of the longer-term intent-by-discovery approach, where users explore alternatives, manipulate outcomes, and home in on their destination.

AI Autocomplete also does not explain why a suggestion appeared, expose unresolved ambiguity, provide rich visual or multimodal exploration, or repair the downstream delivery gap. A beautifully structured prompt can still produce a hallucination, a poor design, or the wrong action.

Autocomplete may just have been promoted from humble search-engine add-on to harbinger of the intent-based future of AI user experience. (GPT Image 2)

AI Autocomplete is therefore a promising bridge between the text-only present and a more usable intent-based future. It may be the strongest commercial implementation yet of a hybrid interface for overcoming the articulation barrier. But my original article called for studies with users across literacy levels performing real tasks. Until such evidence exists, MagicX has demonstrated an excellent design direction, not the disappearance of the articulation barrier. (To make things clear: I am not endorsing this product since I don’t know how well it works outside the vendor demo. Watch users, not demos. But do look into it.)

Constraints Make AI Playable: Lessons from 53 AI-Native Games

A new survey of 53 games built around runtime generative AI finds that the successes pair open-ended generation with hard structure: goals, persistent state, validation, and legible feedback. Generation is cheap; playability must be engineered. Most of these lessons transfer straight to non-game AI products.

A river without banks isn’t a river but a swamp: all water, no direction. Generative AI gives games an endless current of dialogue, quests, characters, and worlds. But current alone produces mush: the banks (rules, goals, state, and feedback) are what turn flow into play.

That’s the core finding of “AI-Native Games: A Survey and Roadmap” by Zhiyue Xu of the Institute of Automation at the Chinese Academy of Sciences and 5 colleagues, including the veteran game-AI researcher Simon Lucas of Queen Mary University of London. The team screened 98 candidate artifacts down to 53 AI-native games and prototypes from 2022 to 2026, then coded each along two axes: the player-facing game type and the AI mechanic that makes the model indispensable.

The Rip-Out Test Separates Native from Decorative

The authors define an AI-native game by a counterfactual: generative AI must be so constitutive of the core loop that removing it would collapse the game or mutate it into a different activity. Call it the rip-out test. Rip out the model; if the game still works, the AI was decoration.

The test yields a tidy 2×2. One axis asks whether generative AI is constitutive of the core loop, or could be ripped out without changing the form of play. The other asks whether the artifact is a strict game at all, with goals, rules, win conditions, and consequential state. Crossing the axes produces 4 quadrants:

Pass both tests, and you have an AI-native game: the AI is load-bearing. In Vaudeville, an interrogation detective game, questioning the model is the game: no model, no suspects, no game.

Keep the game but make the AI replaceable, and you have an AI-augmented game: a real game in which runtime AI enriches a non-core layer. In Tenure-Track Chili, generated dialogue garnishes a loop that would survive on authored content.

Reverse the pattern (central AI, missing ludic structure) and you get an AI-boundary artifact. AI Dungeon offers endless story continuation, but without goals, rules, or win conditions, open-ended storytelling isn’t a strict game.

Fail both tests, and you’ve left game design entirely: plain chatbots and tavern-style role-play offer open-ended conversation with no game attached. All three in-scope categories are legitimate businesses. Only one is AI-native.

Rules, constraints, and a win condition make games flow. If the game designer doesn’t build those, users are lost. (GPT Image 2)

Language Games Dominate the Corpus

Where has the field actually gone? Overwhelmingly toward words. Narrative adventures account for 24 of the 53 artifacts (45%), and the 3 leading AI mechanics (interrogating characters to extract hidden information, persuading or deceiving them, and AI story-mastering) cover a combined 79% of the corpus. Mechanics that push AI deeper into the rules remain scarce: semantic adjudication (the model rules on whether your improvised action succeeds) appears in only 6 games, multi-agent simulation in 4, and generative construction in 1.

Part of the skew is model capability: current AI shines when the interaction is linguistic, and we may expect more video-oriented AI games as world models mature. But part is absorption capacity: detective fiction converts model wobble into unreliable testimony; a strategy game converts it into a corrupted save file. (One quibble: the authors coded this fast-moving corpus themselves, and the census will be stale within a year. The framework will outlive the numbers.)

6 Guidelines for AI-Based Entertainment Design

The survey’s roadmap boils down to the disciplined engineering of freedom. Whether you’re building a detective game, an interactive story, or a companion app, my distillation is:

1. Apply the rip-out test before you brag. If finite authored content or deterministic code could deliver the same experience, you’ve built an AI-augmented product, not a true AI-native game. Fine, but market it honestly.

2. Generate, then verify. Route every model proposal through validators: Does the required object exist? Can the player reach that location? Does the outcome contradict established world state? Rejected proposals get revised or replaced by authored fallbacks. (My heuristic, not theirs: if validators reject more than 1 in 4 proposals, your design space is too open.)

3. Freeze good generations into permanent rules. Infinite Craft caches every element combination, so a recipe discovered once works forever. Caching converts stochastic output into a system players can learn, and slashes the inference bill as a bonus.

4. Design the turn rhythm around latency. When every character reply arrives after an unpredictable multi-second pause, presence evaporates. Historical Simulator: Chongzhen resolves player commands as periodic imperial edicts and reports, hiding inference delay inside the fiction itself.

5. Explain verdicts in game terms, not model terms. “The spell backfired because the effect exceeds your available mana” preserves trust; silent stochastic failure destroys it. Players accept losing. They don’t accept arbitrariness.

6. Reserve the big model for moments that matter. Handle routine behavior with cheap local logic, and spend foundation-model inference only where semantic uncertainty is the point. Marginal cost per interaction belongs in the design brief from day one.

Responsiveness is crucial for gameplay immersion, so lean heavily on smaller, faster AI models for most interactions and reserve the big, slow models for situations that need the extra intelligence. In games, speed usually beats a small step up in intelligence. (GPT Image 2)

The Same Lessons Apply Far Beyond Games

Does any of this matter if you build enterprise software rather than dungeon crawlers? You betcha. Games are where sloppy AI design gets punished fastest: players quit within minutes, whereas office workers suffer in silence for years.

• The rip-out test audits product strategy. Most corporate “AI features” bolted onto existing apps fail it instantly: remove the chatbot, and the product is unchanged (occasionally improved). That classification should drive investment, interface design, and marketing claims.

• Generate-and-verify is the architecture of every trustworthy agent. An AI that files expense reports needs exactly the validators a spell-judging game needs: check preconditions, check state consistency, fail gracefully to a safe default. As I argued in “AI Is First New UI Paradigm in 60 Years,” intent-based interfaces make outcome verification the designer’s job.

• Memory instability demotes users to janitors. The paper notes that when a game forgets its own prior decrees, strategy degenerates into prompt maintenance. Every AI user knows this purgatory: re-explaining context the system should have retained. Persistent, inspectable memory is a feature people will pay for.

• State-anchored explanations beat model transparency. Nobody needs a chain-of-thought dump. Users need the game-design version of explainability, such as “the loan was declined because the debt ratio exceeds 43%”: an actionable reason tied to visible state.

• Latency is an interaction-design material. Games wrap delay in fiction. Productivity tools can wrap it in asynchronous workflows where the agent goes away, works, and reports back, instead of parking the user in front of a spinner.

Games are designed to entertain users during delays. (GPT Image 2)

Games Are the Test Kitchen for AI Interaction

Interaction techniques have a long habit of debuting in games and migrating into serious software. This was true as far back as Spacewar!, which pioneered interactive graphics in 1962, long before anybody had heard of Macintosh, Windows, or the Web. AI-native games are now running that experiment for generative AI, at high speed and with brutal feedback. The 53 pioneers in this survey are discovering, one failed prototype at a time, where the banks must go before the water becomes a river. Don’t dismiss them as toys. Steal their validators, caches, and fallbacks, and your AI product will flow instead of flood.

Bulk Actions: 1 Click, 1,000 Changes, 0 Tolerance for Ambiguity

Bulk actions let users select many items and apply a single command to all of them, collapsing an hour of repetitive clicking into seconds. The efficiency is real, and so is the hazard: the mechanism that archives 500 emails in 1 click deletes 500 in 1 click. Show the scope, permit reversal, and the pattern is pure profit.

Bulk actions in one picture: many items, one funnel, one command. The design job is guaranteeing that users know exactly what’s in the funnel before they press Apply. (GPT Image 2)

Definition: A bulk action is a single operation (for example, delete, move, tag, approve, reprice, or export) applied simultaneously to a user-selected set of items.

The anatomy has three parts: a selection mechanism (checkboxes, shift-click ranges, select all), an action bar that appears once items are selected, and feedback confirming what happened, ideally with an undo attached. Weakness in any of the 3 undermines the other 2.

From Punch Cards to “Select All Conversations”

The mindset is older than the screen. Batch processing, the dominant computing paradigm from roughly 1945 to 1965, meant submitting a deck of punch cards and letting the machine grind through the whole stack; operating on records one at a time would have struck those operators as absurd. Command lines then handed individuals the same mass leverage: rm *.bak deletes every matching file instantly, silently, and without appeal, which is why graybeard system administrators trade scar stories about it.

The danger of bulk actions: one command can do a whole lot of damage. Provide undo. (GPT Image 2)

Graphical multi-select arrived with the Xerox Star (1981) and reached ordinary users with the Macintosh (1984), via shift-click and the rubber-band marquee. The modern reference implementation is Gmail (2004): select one page of conversations, and a quiet link offers to extend the selection to every conversation matching the search. That link is the pattern at its most powerful and its most dangerous, in roughly 10 words of blue text.

Why Bulk Actions Work: The Arithmetic Is Brutal

Why do power users beg for this feature? Walk through the numbers. A knowledge worker archiving 200 stale emails one at a time spends about 3 seconds per message, or 10 minutes of click-and-wait drudgery. Select all, archive: about 5 seconds. That’s a 120× speedup on one mundane chore. Now scale it up: a merchandiser repricing 3,000 products, a moderator resolving 800 flagged posts, an administrator deactivating the accounts of 60 departed employees. Without bulk actions, these jobs are measured in days; with them, in minutes. A prime example of usability heuristic number 7, Flexibility and Efficiency of Use.

Speed is only half the win. Consistency (heuristic 4) is the other half: one command produces one uniform result, whereas 3,000 manual repetitions guarantee that item 173 gets forgotten and item 2,418 gets the wrong tag. Machines excel at monotony. Let them have it.

How Bulk Actions Fail: Invisible Cargo

The signature catastrophe is scope confusion with invisible cargo, the items swept into an operation that the user never laid eyes on. The 3,387 matching conversations sitting on pages 2 through 136, included via “select all.” The selection that silently persisted after the user changed filters and forgot about it. Cargo can also vanish invisibly: a selection that resets when the user flips to page 2 discards 10 minutes of careful checkbox work without a word. Persisting and resetting are both defensible policies; doing either invisibly is not.

It is risky if the user only sees a few objects, but the bulk action hauls along a huge additional invisible cargo. Powerful features like bulk actions must take extra care to communicate what they will do in advance and provide clear feedback after they have completed. (GPT Image 2)

Second, irreversibility. Ben Shneiderman put “permit easy reversal of actions” in his golden rules of interface design in 1985, observing that reversibility relieves anxiety and invites exploration. (I assigned the same duty to user control and freedom in my 10 usability heuristics in 1994. This requirement has been on the exam for 41 years, folks.) A destructive bulk action without undo converts one misread dialog into a résumé-updating event.

Third, partial applicability: the action is valid for 480 of the 500 selected records, and the system either fails everything or, worse, applies it to 480 and says nothing about the other 20. Fourth, mid-job failure: a 5,000-item operation times out at item 2,612, leaving a half-applied state murkier than either doing nothing or finishing.

Every one of these has a known cure, listed below. None of the cures is exotic. All of them get skipped weekly by teams shipping admin panels.

9 Design Guidelines for Bulk Actions

1. Show a persistent selection count. “3,412 selected” must stay visible beside the actions at all times; the count is the user’s only window into the cargo.

2. Make select-all scope an explicit 2-step choice. Selecting the visible page and extending to all matches are separate, labeled decisions, à la Gmail.

3. Declare what happens to selections when the context changes. If flipping pages or editing filters keeps or clears the selection, say so on screen at that moment.

4. Attach undo to every reversible action. An undo toast lasting 10–30 seconds converts most bulk mistakes into non-events.

5. Scale the friction to the destructiveness. For irreversible operations on large sets, require typing the item count or a keyword; a 1-click confirmation dialog gets dismissed on autopilot.

6. Offer a preview on demand. A “review the 3,412 items” link before executing catches a mis-scoped selection while the mistake is still free to fix.

A preview feature will prevent many mistakes. (GPT Image 2)

7. Report partial results precisely. “480 updated, 20 skipped (locked)” with a list of the 20; a bare “Done” hides failures the user will discover at the worst possible time.

8. Run big jobs in the background. Show progress, allow cancellation, and deliver a completion report instead of freezing the interface or timing out halfway through.

9. Keep an audit trail. Record who applied which action to how many items and when; in enterprise systems, the log is what turns a disaster into a recoverable incident.

Users will love you for bulk actions that multiply their leverage and delete their tedium. (GPT Image 2)

“Lorem Ipsum” AI Film Wins Bronze Lion at Cannes

At the recent Cannes Lions International Festival of Creativity, Purga Studio won bronze in the Film Craft category for three AI-generated short films, all titled “Lorem Ipsum”: Mafia, Samurai, and Western (YouTube, each about 2 min.).

Lorem ipsum was the traditional placeholder text used in design mock-ups while awaiting final copy. It had its day. (Reve 2.1)

I won’t give away the tagline, but it explains why they made 3 films in different genres from the same script. Readers of a certain age will appreciate the “lorem ipsum” joke. Luckily, those pseudo-Latin lines are a thing of the past now that AI can generate more appropriate placeholder text for any draft design.

AI creates realistic placeholder text, banishing “lorem ipsum dolor sit amet” to the fringes, and to nostalgic AI movies. (GPT Image 2)

It’s impressive that Purga won bronze in the general Film Craft category for these AI films, given that the Festival also had a special category for AI films. This is proof that AI movies are gaining on legacy production methods, though, of course, still only at the bronze level, not gold. And only for short work, not feature films. Yet!

Three movie genres, same script; makes sense. (Not the script in my cartoon, of course.) A creative achievement by Purga Studio. (GPT Image 2)

Some AI creators are attempting longer work. The Next Show has produced AI versions of Aladdin (YouTube, 1 hr. 31 min.) and The Odyssey (YouTube, 23 min.). The published video of Aladdin is described as “Season 1,” and probably covers only 1/3 or 1/2 of the story, meaning that the final AI film will be 3 hours or more. The clip from The Odyssey only covers the episodes where Odysseus visits the Cyclops and the Sirens, plus some parallel exposition of Penelope’s troubles with the suitors on Ithaca. This equates to most of the poem’s Books 9 and 12, plus picking up Penelope’s ruse with her loom from Book 2. The material related in the 23-minute AI video covers roughly 1/12 of The Odyssey’s 24 books, meaning that the final film would run for almost 5 hours if it were to cover everything.

In my judgment, these AI adaptations of Aladdin and The Odyssey are of roughly B-movie quality, so they probably wouldn’t win bronze at an international festival. That said, the special effects in both AI films are much better than anything a B-movie ever put on screen. Special effects are an AI strength, and it can put the giant Polyphemus in the same frame as human-sized “actors” without breaking a sweat.

A giant character doesn’t pose a giant problem for an AI video model. In fact, rendering the Cyclops is no more expensive than rendering Odysseus. (Muse Image)

I actually enjoyed watching both of these longer AI works. Other viewers agree, since Aladdin racked up 2 million views in the first few days after release, which is more than almost any production from legacy Hollywood studios can boast. (The recent legacy production of The Odyssey only sold about a quarter of a million tickets over the same period, but admittedly, those were paid tickets, whereas YouTube videos are free to watch, except for having to sit through some ads.)

I don’t think the AI version of The Odyssey is captivating enough for me to watch the complete film. But that’s this year’s AI. Next year’s AI movies might be able to pull off a full-length feature film. (GPT Image 2)

The AI work that has enthralled me most recently sticks to short episodes but stitches many of them into one long story: the Chinese mini-movie series “My Uncle Don Quixote.” Unfortunately, I don’t think this series is available on regular Western video services like YouTube; I’ve only been able to find the first 3 episodes reposted on X by user 沐阳.

The story is about a Chinese teenager who flies to New York to live with his uncle, who moonlights as a literal knight in shining armor. (Thus, the title.) The show presents a very Chinese take on New York City, but that’s part of its charm.

Short films of up to maybe 5 minutes are still the format where AI shines. A big pile of AI clips doesn’t quite make for a great feature-length movie yet. (Muse Image)

All the videos I have linked in this news item have impeccable production quality, and for Lorem Ipsum and My Uncle Don Quixote, I don’t think you can really tell the characters are AI-generated rather than live human actors. (Aladdin and The Odyssey have a bit more wooden acting and a few unnatural movements.) Lorem Ipsum was made with Kling, and My Uncle Don Quixote was almost certainly made with Seedance 2.5 (sadly not available outside China yet, but it’s an astounding video model).

The best AI videos from Seedance 2.5 are so good that it’s virtually impossible to tell AI characters from the human actors the legacy movie studios will probably keep using for another few years, hidebound as they are by tradition. (GPT Image 2)

The Peak–End Rule: Users Remember 2 Moments and Forget the Rest

People judge a past experience by its most intense moment and its final moment, largely ignoring duration and the average of everything else. Fix your journey’s worst moment, build 1 genuine high point, and never let an error be the last thing users see: memories, not experiences, drive repeat business and word of mouth.

Memory compresses a whole journey into 2 data points: the highest peak and the grand finale (whether it’s grand or not: whatever comes last is what’s remembered). The 40 uneventful steps in between might as well never have happened. (GPT Image 2)

Definition: The peak–end rule states that a person’s retrospective evaluation of an experience approximately equals the average of its emotional peak (the most intense moment, good or bad) and its end. Duration barely matters, a companion effect called duration neglect that Barbara Fredrickson and Daniel Kahneman documented in 1993.

Kahneman (Princeton, Nobel laureate in 2002) framed the underlying split as two selves: the experiencing self, who lives through every second, and the remembering self, who keeps a heavily edited highlight reel. Here’s the commercially decisive part: the remembering self writes the reviews, renews the subscription, and recommends you to friends. The experiencing self doesn’t get a vote.

Cold Water and Colonoscopies: How the Rule Earned Its Name

The name is literal: evaluation ≈ the mean of Peak and End. The evidence is famously uncomfortable. In the cold-pressor experiment by Kahneman, Fredrickson, Schreiber, and Redelmeier (1993), participants held a hand in painful 14°C water for 60 seconds and, in a second trial, endured the same 60 seconds plus 30 extra seconds while the water warmed slightly to 15°C. The longer trial contains strictly more pain, yet when asked which trial to repeat, a significant majority chose it, because it ended better.

Donald Redelmeier and Kahneman then measured real medicine (1996): among 154 colonoscopy patients (plus 133 undergoing lithotripsy), remembered pain tracked the peak intensity and the final 3 minutes, while lengthy procedures were not remembered as worse. A follow-up randomized trial with 682 patients (Redelmeier, Katz, and Kahneman, 2003) left the scope resting briefly at the end, a finish that was mildly uncomfortable but calmer than what preceded it. Result: better remembered ratings and a higher rate of return for follow-up procedures. A worse experience produced a better memory, and the better memory produced better health behavior (returning for the next recommended test). Homer grasped the principle 2,700 years earlier: we remember The Odyssey for the Cyclops and the homecoming, not the years of rowing in between.

We remember these two moments (the action peak and the ending) best from the poem, and they may even be what Odysseus himself dwelt on when telling the tale to his grandchildren 20 years after his homecoming. (Muse Image)

Design for the Remembering Self

UX teams instrument the experiencing self (task times, error rates, click paths) and then wonder why satisfaction scores diverge from the analytics. The peak–end rule tells you where the memory actually gets made:

Endings. The confirmation page after checkout is routinely the most neglected screen in e-commerce, yet it’s the final memory of the purchase. Support interactions live or die on the resolution moment. Offboarding matters most of all: companies treat cancellation flows as damage control, but cancellation is the last thing a churning customer experiences, and contempt at the exit forecloses the return. IKEA figured this out long ago; the 1-dollar hot dog by the exit is peak–end engineering in flat-pack form.

Peaks. Every journey deserves a deliberate high point tied to genuine user success: the first deployment that works, the report that finally renders, the payment that lands. Make the moment of accomplishment unmistakable.

3 Ways to Abuse the Rule

Abuse 1: the mint on a pile of misery. Confetti on the final screen won’t outweigh a rage-inducing failure in the middle, because that negative moment is the peak, and it enters the memory average at full force. Fix the worst moment first; decorate later.

Abuse 2: gaming your own metrics. Prompting for a rating precisely at the emotional high point inflates scores and blinds the organization to real problems. Asking at a natural completion moment is fine; using peak timing as anesthesia for a bad product is self-deception with a dashboard.

Abuse 3: confetti inflation. When every trivial click triggers a celebration, peaks flatten into wallpaper and genuine achievement drowns. Ration the fireworks.

One boundary condition keeps designers honest: the rule describes the memory of an episode, not immunity to repetition. A product that hurts users daily mints a fresh bad memory every day, and duration neglect won’t protect you from 200 accumulated grudges. Slow, tedious flows still need fixing. The rule only tells you which moments the memory will keep.

8 Design Guidelines from the Peak–End Rule

1. Map the emotional journey first. Identify today’s peak (often negative) and today’s ending before redesigning anything.

2. Repair the most negative moment. It’s currently your peak, whether you chose it or not.

3. Close every flow explicitly. A success confirmation plus “here’s what happens next” beats a silent redirect.

4. Lavish attention on final screens. Order confirmations, export-complete pages, and sign-off states are prime memory real estate.

5. Design offboarding like onboarding. Make cancellation quick and gracious; call it the exit dividend: courtesy invested in the last 30 seconds pays returns for years.

6. Build one genuine peak per journey. Tie it to the user’s accomplishment, not to your brand animation.

7. Never end on an error. After recovery, route the user to a reassuring, stable place before he or she leaves.

8. Schedule unavoidable unpleasantness early. Identity checks and paperwork belong before the finale, so the journey ends on accomplishment rather than bureaucracy.

You can’t polish every second of a long experience, and the peak–end rule says you don’t have to: memory grades on 2 items. Engineer one honest high point, then walk your users out through the golden doorway instead of shoving them through a side exit. The journey ends; the memory is just getting started.

Time in AI Apps Doubled in a Year: 36 Billion Hours in H1 2026

People spent roughly 36 billion hours inside AI apps worldwide in the first half of 2026, more than double the 17.2 billion of H1 2025. (The US numbers were 4.0 billion hours in H1 2026 vs. 2.6 billion in H1 2025: slower growth in this more mature market.) Consumer spending on those apps hit $4.2 billion, up from $1.83 billion a year earlier: 130% annual growth, even faster than the growth in hours. Downloads reached nearly 2.3 billion. Those figures come from Sensor Tower’s State of AI report, summarized here.

Humanity spent 36 billion hours in AI apps during the first half of 2026. Assuming that growth continues, the full year will reach about 80 billion hours. (GPT Image 2)

Why should UX people care about app-store accounting? Because behavior beats surveys. Self-reported adoption studies tell you what people say; a doubling of measured hours tells you what they do. And the monetization jump is the tell: paying $4.2 billion in 6 months is revealed preference, the strongest usability signal money can express. Free curiosity is cheap. Wallets aren’t.

Users spent 130% more money on AI in the first half of 2026 than the first half of 2025. That’s a revealed preference that says that AI works so well for people that they’re willing to pay for it. (GPT Image 2)

The competitive picture matters too: 18 months ago, ChatGPT dominated; now, 8 platforms each top 100 million users worldwide. The largest AI platform by monthly active users (MAU) is Meta AI, with 1.2 billion, thanks to its embedding within Facebook, Instagram, and WhatsApp. The largest platform by actual use (frequency included, not just one stop per month) remains ChatGPT, with about twice the usage of Gemini.

Meta is the company exposing the largest number of individuals to AI because its AI rides inside three of the world’s most-used apps (Facebook, Instagram, WhatsApp). However, intense and deliberate AI use is still concentrated in other apps, where ChatGPT continues to lead. (GPT Image 2)

Fragmentation means users are comparison-shopping AI experiences, so interaction quality finally becomes a competitive weapon rather than a nice-to-have. Switching costs in chat interfaces are nearly zero: users can defect mid-sentence. The product with the least friction wins the marginal session.

Will this doubling every year continue? Nothing is forever, especially exponential growth, but there’s substantial headroom: most people still aren’t advanced AI users, even if they’ve dabbled. A few more years of annual doubling are quite feasible.

A Final Thought

(Yes, this section exists because of the peak–end rule.)

About the Author

Jakob Nielsen, Ph.D., is a usability pioneer with 43 years experience in UX and the Founder of UX Tigers. He founded the discount usability movement for fast and cheap iterative design, including heuristic evaluation and the 10 usability heuristics. He formulated the eponymous Jakob’s Law of the Internet User Experience. Named “the king of usability” by Internet Magazine, “the guru of Web page usability” by The New York Times, and “the next best thing to a true time machine” by USA Today.

Previously, Dr. Nielsen was a Sun Microsystems Distinguished Engineer and a Member of Research Staff at Bell Communications Research, the branch of Bell Labs owned by the Regional Bell Operating Companies. He is the author of 8 books, including the best-selling Designing Web Usability: The Practice of Simplicity (published in 22 languages), the foundational Usability Engineering (31,140 citations in Google Scholar), and the pioneering Hypertext and Hypermedia (published two years before the Web launched).

Dr. Nielsen holds 79 United States patents, mainly on making the Internet easier to use. He received the Lifetime Achievement Award for Human–Computer Interaction Practice from ACM SIGCHI and was named a “Titan of Human Factors” by the Human Factors and Ergonomics Society.

· Subscribe to Jakob’s newsletter to get the full text of new articles emailed to you as soon as they are published.

· Follow Jakob on LinkedIn.

· Read: article about Jakob Nielsen’s career in UX

· Watch: Jakob Nielsen’s first 41 years in UX (8 min. video)

Summary: AI narrows skill gaps by helping weak performers the most. Market data shows employers reacting: hiring in AI-exposed job categories now weights human capital 7.8% less and price 1.1% more and the demand premium for highly skilled workers is shrinking. Competence has become a commodity, so sell judgment. Agentic AI will reverse the equalization and widen skill gaps again, this time around the skill of deciding what to build and picking the best AI output.

AI is a forklift for the mind. A real forklift lets a scrawny warehouse worker and a bodybuilder move identical 1,000-kg pallets: once the machine does the lifting, muscle stops predicting output. AI does the same for knowledge work, which is why the weakest performers gain the most from it. I’ve made this argument since 2023 (see, for example, AI Makes Happy Geeks), and every controlled experiment since has piled more weight onto the pallet.

One of my oldest metaphors: AI is a forklift for the mind. It helps everybody lift cognitive burdens and thus narrows the skill gaps between the most and least talented knowledge workers, just as a real forklift narrows the gap between muscular and weak warehouse workers. (Muse Image)

Experiments measure the supply side: what AI does to the work. But what happened to demand? Do the people who buy work agree that competence has become a commodity? A new study from UCLA’s Anderson School of Management delivers the first hard market data, drawn from 2.26 million freelance contracts, and the answer is yes: in AI-exposed occupations, clients pay less attention to skills, credentials, and reputation, and more attention to a single number, the price. In this article, I dissect the new market evidence, recap the experiments that explain it, draw the consequences for UX careers, and then argue (speculation, plainly labeled) that the next generation of AI will reverse the equalization and hand the advantage back to the most talented. It’s a long article, but then again, it’s your paycheck.

Credentials and reputation now carry less hiring weight, according to the analysis of more than 2 million contracts. (GPT Image 2)

The Market Has Noticed: Data from 2.26 Million Contracts

Auyon Siddiq and Niuniu Zhang of UCLA’s Anderson School of Management pulled the hiring records of Upwork, the large online labor market where clients contract freelancers for short jobs in writing, design, coding, accounting, translation, and customer support (SSRN working paper, 2026). Their panel tracks 49,610 freelancers who were active before ChatGPT arrived, observed quarterly from January 2021 through March 2026: 21 quarters and 2.26 million completed contracts spanning the AI shock of November 30, 2022. No survey, no vibes: this is revealed preference, recorded 2.26 million times, with money attached.

The research question is more nuanced than the usual “did AI kill freelance jobs?” We already know demand fell in exposed categories: Xiang Hui, Oren Reshef, and Luofeng Zhou documented the drop in 2024, and Ozge Demirci and colleagues confirmed it from the job-posting side in 2025. Siddiq and Zhang ask a subtler question: did AI change what clients look at when choosing among freelancers? If AI commoditizes labor, skill signals should lose hiring weight and the price tag should gain it. Spoiler: both happened, on schedule, in the AI-exposed categories only, and kept intensifying for 3 years.

As AI equalizes the quality of the results, clients increasingly choose by price instead of by who has the fanciest credentials and the longest experience. (Muse Image)

What Clients See: 3 Bundles of Human Capital, Plus a Price Tag

Definition: Human capital is economists’ term for the stock of skills, education, and experience that makes a worker productive; the concept helped win Gary Becker the 1992 economics Nobel.

A client can’t observe a freelancer’s productivity before hiring; he or she sees only signals. The study sorts everything visible on an Upwork profile into 3 bundles of human capital signals, plus one factor that isn’t human capital at all:

• Self-presentation: the freelancer’s chosen title (“Experienced iOS Developer”), written description, and skill tags: what workers say about themselves.

• Credentials: degrees, institutions, employment history, and portfolio projects. External validation, and costly to change. (You can rewrite your skill tags over coffee; you can’t rewrite your diploma.)

• Reputation: prior contracts, client ratings, written feedback, and platform badges such as “Top Rated,” all generated inside the market by actual transactions.

• Price: the posted hourly rate. One number, no prose.

The 3 human capital bundles a client can inspect before hiring: how workers describe themselves, what their credentials certify, and what past clients said. The fourth factor, price, is the one AI is teaching buyers to favor. (GPT Image 2)

Signals saturate this market: 97% of the freelancers list education, 83% show a portfolio, and 98% carry at least one client rating. Demand, by contrast, is feast or famine: the mean freelancer lands 2.17 contracts per quarter, but the median freelancer lands zero. Abundant signals chasing scarce buyers: exactly the market where hiring signals should matter enormously. Which makes it all the more striking when buyers start ignoring them.

How Do You Weigh a Resume? With 16 Regressions and a Nobel Idea

The awkward fact about worker profiles is that they’re mostly prose, and prose resists spreadsheets. The traditional fix hand-codes a few variables (years of education, true/false for “knows Python”) and discards the rest. Siddiq and Zhang instead convert each text bundle into an embedding: a list of 384 numbers, produced by a language model, positioned so that texts with similar meanings land near each other. Whole profiles enter the statistical machinery, with no researcher deciding in advance which words matter.

Next, they predict each freelancer’s quarterly demand from all 4 blocks, quarter by quarter, with cross-validation so the model is always judged on freelancers it never saw during training. (Profiles plus price explain roughly 1/3 of the variation in demand; the rest is timing, luck, and everything a profile can’t show.)

Then comes the Nobel idea. To measure how much each block matters, the authors compute Shapley values, a credit-assignment method that Lloyd Shapley invented in 1953 for cooperative games (he later collected an economics Nobel, and his method now powers most of explainable AI). The recipe: fit all 16 possible models, one per subset of the 4 blocks, and average each block’s marginal contribution. The result: for every freelancer in every quarter, predicted demand splits exactly into a self-presentation share, a credentials share, a reputation share, and a price share.

Finally, the causal design. The authors grade each of Upwork’s 102 job subcategories with the AI exposure scores from Tyna Eloundou and colleagues’ “GPTs are GPTs” (published in Science in 2024): the share of an occupation’s tasks that an LLM alone could complete twice as fast at equal quality. Translation tops the scale at 0.80; photography sits near zero. (That would be zero AI risk for the freelance job of “portrait of my beloved dog in my apartment,” not for “give me a photo of a cute dog,” which AI does perfectly without needing to go on location.)

This is nobody’s dog, so I didn’t need to hire a freelancer for the shoot. Meta’s new Muse Image model whipped up this pampered pooch in a few seconds of rendering time.

The study then compares the trajectory of the 4 block weights in exposed vs. unexposed categories, before and after ChatGPT: a difference-in-differences design, the workhorse of modern policy evaluation. One detail deserves applause: because profiles are measured once (a March 2026 snapshot), any movement in the weights reflects a change in the market’s hiring rule, not a change in the profiles. The freelancers held still; the buyers moved.

The Findings: Skills Pay Less, Price Matters More

Start with the anchor. After ChatGPT, contract volume for freelancers in the most exposed job category fell 7.0% relative to unexposed categories, replicating the earlier demand studies. The news is how that decline was distributed across the hiring signals:

• Self-presentation lost 2.8% of its importance for demand, credentials lost 2.4%, and reputation lost 2.9%. Combined, the human capital bundles lost 7.8% of their hiring weight.

• Price gained 1.1%.

Every human capital coefficient is negative, the price coefficient is positive, and all clear the 1% significance bar. Note the breadth: the discount hit not only self-descriptions (which AI made cheap to fake) but also verified diplomas, employment histories, and 5-star ratings earned through real transactions. Buyers stopped caring even about proof.

Worse (or better, depending on your side of the trade), the effects steepen over time instead of fading:

Across 49,610 freelancers and 2.26 million contracts, hiring in the most AI-exposed job categories shifted weight away from human capital (7.8% less important) and toward price (1.1% more important) after ChatGPT launched, while contract volume in those categories fell 7%. All these trends were stronger in recent quarters than in the full period Siddiq and Zhang analyzed.

More than 3 years after the shock, the lines still point the wrong way for credential holders: a repricing in progress, not a blip being absorbed. Pre-ChatGPT trends were flat for all 3 human capital bundles, so the divergence starts exactly when the technology arrived. We now have a credential discount, the markdown that AI-exposed markets apply to diplomas, portfolios, and ratings. The credential discount deepened every year of the study.

Credentials are worth less and less. (GPT Image 2)

The Commoditization Tests: Premiums Shrink and Demand Flows Downmarket

A skeptic could accept everything above and still resist the commoditization story. Maybe clients started treating a high price as a quality signal (economists have modeled price-as-quality since Paul Milgrom and John Roberts in 1986), which would also make price more predictive of hiring. So Siddiq and Zhang ran two additional tests, and this is where the paper shines.

Test 1: Does the skill premium shrink? Rank freelancers by the pre-AI strength of their human capital signals and compare the top half to the bottom half. Before ChatGPT, strong-signal freelancers enjoyed a fat demand premium. After ChatGPT, that premium compressed by 6.2% in the most exposed categories, and by 10.3% in the study’s final 4 quarters. The workers with the most impressive signals lost the most differentiation, precisely where AI hit hardest.

Before AI, strong human capital signals earned freelancers a hefty demand premium over weaker rivals. After ChatGPT, that premium compressed by 6.2% in the most AI-exposed categories, and by 10.3% in the study’s final year. (Data: Siddiq & Zhang, 2026.)

Test 2: Where does the demand go? Compare higher-priced freelancers to cheaper ones. If clients had started reading price as a quality signal, demand should have shifted upmarket toward expensive workers. It went the other way: demand shifted toward cheaper freelancers, by 3.2% in the pooled estimate and an accelerating 7.9% in the final 4 quarters. (The top-skill and top-price groups barely overlap, correlating at only 0.07, so the second test isn’t the first one wearing a cheaper suit.) Price sensitivity won. Quality signaling lost.

Together, the two tests match the theory of labor commoditization proposed by Masao Fukui of Boston University with Emi Nakamura and Jón Steinsson of UC Berkeley (Nakamura holds the John Bates Clark Medal, economics’ junior Nobel, so this is no fringe framework). The mechanism: AI compresses quality differences between workers’ outputs, workers become more substitutable in clients’ eyes, and hiring collapses onto the one dimension that still separates candidates. The price.

The commoditization mechanism in one picture: AI raises weak performers’ output more than strong performers’, the quality gap narrows, and workers become more substitutable in clients’ eyes. Once outputs converge, price is the differentiator left standing. (GPT Image 2)

How solid is all this? The authors shuffled the AI exposure scores randomly across the 102 job subcategories 2,000 times and re-ran everything. Not one shuffle reproduced the observed pattern of 3 human capital declines plus a price increase (p < 0.0005). The result is glued to actual AI exposure, not to a quirk of the categories.

Time for the methodological cold shower, because no observational study escapes one. Profiles come from a single March 2026 snapshot, so the study assumes credentials and prices were stable (defensible: diplomas don’t fluctuate, and posted rates vary 6 times more across workers than within them, but still an assumption). Freelancers who deleted their accounts are invisible, which makes the estimates conservative, since the biggest losers left the sample. The study observes hiring outcomes, not the proposals and search rankings behind them. And it covers one platform: a freelance marketplace, not payroll employment. But the paper argues, and I agree, that the same screening logic governs resumes, references, and salary negotiations everywhere; the marketplace just renders it measurable. For market data, this is about as clean as the genre gets, and the robustness checks (3 prediction models, 2 embedding models, same story) beat the evidentiary standard of every AI hot take you’ll read this week.

So the demand side has spoken. To see why clients behave this way, and why they’re broadly right to, turn to the supply side: the experiments showing what AI does to the quality gap between workers.

The Lab Evidence: AI Lifts the Bottom Harder Than the Top

The skill-gap finding isn’t one study; it’s a research program spanning writing, programming, consulting, customer service, product innovation, and law, with data running from small 2023 lab tasks to 2026 field deployments at global scale. The headline numbers:

AI helps everybody, but extensive evidence shows that it lifts the least-skilled workers the most, raising the talent floor. (GPT Image 2)

• Business writing. Shakked Noy and Whitney Zhang of MIT had 453 college-educated professionals write realistic documents such as press releases and analysis memos (Science, 2023). ChatGPT users finished 40% faster with 18% higher quality, as judged by blind graders. The biggest quality jumps went to the participants who wrote worst without AI, and the link between unaided skill and final grade weakened sharply once ChatGPT entered the picture.

• Customer support. Erik Brynjolfsson, Danielle Li, and Lindsey Raymond studied more than 5,000 support agents at a Fortune 500 software firm whose AI assistant was trained on transcripts from top agents (NBER, 2023, since published in the Quarterly Journal of Economics). Productivity rose 14% on average but 35% for novice and low-skill agents, with next to nothing for the most experienced. A 2026 field experiment with roughly 6,000 agents at Alibaba’s Taobao marketplace replicated the shape (arXiv, 2026): low performers improved the most on both speed and quality, while top performers gained little speed and even slipped on quality, partly because the assistant’s suggestions ran below their own standards and partly because they multitasked more.

• Management consulting. Fabrizio Dell’Acqua and colleagues at Harvard Business School ran 758 BCG consultants through 18 realistic tasks (SSRN, 2023, since published in Organization Science). On tasks within AI’s capability frontier, quality rose roughly 40%. Consultants in the bottom half of the skill distribution improved 43%; the top half improved 17%.

• Product innovation. Fabrizio Dell’Acqua, Karim Lakhani, and colleagues ran a preregistered field experiment with 776 professionals at Procter & Gamble working on real new-product challenges (NBER, 2025). Individuals with AI matched the performance of 2-person teams without it, and AI dissolved expertise boundaries: R&D staff produced commercially balanced proposals and commercial staff produced technically balanced ones. The skill gap narrowed not just within specialties but across them.

• Programming. Sida Peng and colleagues at GitHub and Microsoft timed 95 developers building an HTTP server (arXiv, 2023). The GitHub Copilot group finished 56% faster, with the largest speedups among less-experienced developers. The result then scaled: 3 field experiments at Microsoft, Accenture, and a Fortune 100 manufacturer gave 4,867 working developers Copilot during their day jobs (Management Science, 2026); completed tasks rose 26%, again with the highest adoption and the largest gains among the least experienced.

• Law. Jonathan Choi and Daniel Schwarcz gave University of Minnesota law students GPT-4 on realistic law-school exams (73 Journal of Legal Education, 2025). Students at the bottom of the class saw huge gains; students at the top actually declined. (And file away a second finding for later: with good prompting, GPT-4 alone outscored both the average student and the average AI-assisted student.)

All 9 studies used randomized or staggered rollouts of AI access and measured performance with blind grading or objective output counts, so these are causal effects, unlike the self-reported enthusiasm that passes for evidence on social media.

One boundary condition deserves airtime before anyone extrapolates that table to infinity. In a 2025 randomized trial by the research group METR (study report), 16 veteran open-source developers worked on their own mature codebases, projects they had maintained for 5 years on average, with each task randomly assigned to allow or forbid AI tools. With AI, they finished 19% slower, while believing afterward that AI had sped them up by 20%. The forklift lifts from below: hand one to somebody already standing at the top of his or her own staircase, and it mostly gets in the way, while feeling helpful the whole time. (That 39-point gap between perceived and measured productivity is also a standing caution against every self-reported AI statistic you will ever read.)

Different professions, different countries, different AI models, different years: same shape. By 2024, I considered the narrowing of skill gaps settled science for current AI on production tasks. Hold onto that qualifier, “production tasks.” It returns with a vengeance below. And notice how neatly the lab record explains the market record: Upwork clients down-weight skill signals because AI has genuinely made skill a weaker predictor of output quality. The buyers are simply arbitraging a real change.

Why the AI “Forklift” Helps the Weak the Most

Consider what forklifts did to warehouses. (Clark built the first recognizable forklift around 1917, and World War II logistics made pallets and forklifts the global standard.) Before the machine, a warehouse paid a premium for strong backs. After the machine, strong and weak moved the same pallets at the same speed, and physical strength dropped out of the wage equation. The forklift didn’t make anyone stronger. It made strength irrelevant to the task of moving boxes.

Why does the cognitive version lift from the bottom? Five mechanisms, all visible in the studies above:

1. AI performs at a roughly fixed level, no matter who’s prompting. For everyday professional tasks, a frontier model writes at perhaps the 80th percentile of the profession. Work the math: Bob, a 30th-percentile writer, accepts the AI draft and jumps 50 percentile points. Alice, a 95th-percentile writer, would drop 15 points by shipping the raw draft, so she edits heavily and gains mostly time. The model’s fixed competence acts as a rising floor and a magnetic middle.

2. AI bottles the tacit knowledge of top performers. The customer-support study makes the mechanism explicit: the assistant was trained on the best agents’ transcripts, so novices got the firm’s stars whispering in their ears all day. Experts gained nothing from hearing their own advice repeated back to them.

3. Recognition outruns production. Most professionals can recognize quality they can’t yet produce. (Human memory judges far better than it generates, which is also why my usability heuristic “recognition rather than recall” works.) AI converts recognition skill into production skill: a junior designer who can merely tell the good option from the bad ones can now ship the good one.

4. Current AI supplies mechanics rather than judgment. Grammar, structure, boilerplate, standard frameworks: exactly the ingredients weak performers lack. Top performers’ edge sits in judgment, taste, and originality, which current models supply in thinner doses. Patch the weak spot of the weak, and the gap closes from below.

5. Grading scales have ceilings, and experts start near them. On a 0–10 rubric, an expert scoring 8.5 has 1.5 points of headroom; a 4.0 performer has 6. The narrowing is real, but ceiling effects compress it further at the top, so treat the exact percentages with mild suspicion.

A Central Bank Runs a Clean Experiment

Aleš Maršál of the National Bank of Slovakia and Patryk Perkowski of Yeshiva University produced the tidiest supply-side test yet: a preregistered, randomized field experiment inside Slovakia’s central bank (working paper, 2025; the authors also wrote a short summary at VoxEU). In June 2024, 101 of the bank’s roughly 1,100 employees completed a 2-hour battery of genuine workplace tasks for real money (base pay plus a performance bonus).

The task design is the paper’s quiet masterstroke. Instead of studying a single job, the authors sampled the full task spectrum that labor economists have used since David Autor and colleagues formalized it in 2003: routine and non-routine cognitive tasks (proofread a sloppy paragraph; invent novel uses for a paperclip), routine and non-routine manual tasks (data entry; explain how to un-jam the office printer), plus analytical, leadership, and communication tasks, 14 generalist tasks of about 4 minutes each. Then came 2 specialist tasks of 30 minutes each: economists decomposed GDP and fit a forecast, IT staff wrote and benchmarked code, and payments staff handled a simulated breach of the settlement system. (Central bankers steer the money supply for roughly 350 million Europeans, but the jammed printer remains undefeated as an office challenge.)

Every participant did one task of each pair with OpenAI’s GPT-4o and its twin without, with the IT department blocking the tool for control tasks and one of the authors sitting in the room to keep everyone honest. Employees used GPT-4o on 94% of eligible tasks and 0% of control tasks. Try getting 94% uptake on any other corporate software rollout! Grading was blind, on 0–10 rubrics, with industry professionals scoring the specialist work.

The results: quality rose 33–44%, depending on the statistical specification, and completion time fell 21%. 94% of participants scored higher with AI than without, each employee serving as his or her own control. Quality and time gains were uncorrelated: people banked both.

Where the study earns its keep is the breakdown by task type:

Definition: A complementarity exists when two ingredients are worth more combined than the sum of their separate effects. Using a formal test borrowed from Brynjolfsson and Milgrom, the authors find a strong complementarity between AI and non-routine work: roughly 0.9 standard deviations of extra performance beyond AI’s effect on routine tasks. AI helps with the predictable stuff; it helps even more with the open-ended stuff. So much for the folk theory that chatbots only automate drudgery.

The specialist tasks deserve a second look. Performance more than doubled (a whopping +113%), but from a dismal base of 2.2 out of 10, and even AI-assisted employees averaged only 4.9. Hard expert work stayed hard: AI turned failing grades into mediocre ones, still the largest jump in the experiment. And many participants who already used AI at work told the authors this was their first attempt at applying it to advanced specialist tasks. The frontier of AI usage inside organizations sits well behind the frontier of AI capability.

Now the nuance that complicates the equalization story. On generalist tasks, lower-skill employees gained the most quality, replicating every study in my table above. But equalization stopped there. On efficiency, the pattern reversed: high-skill workers gained the most speed (a noisier result, the authors note). On specialist tasks, equalization vanished entirely: the skill gradient disappeared, and the debriefs suggested that high-skill workers with prior AI exposure integrated the tool best on hard problems. (And returns were identical for men and women, so the well-documented gender gap in AI adoption is an on-ramp problem; fix the on-ramp, and the gap should close.)

A quick cold shower for this study too: participants from a central bank, 92% holding at least a master’s degree, hardly mirror the labor force, and 4-minute generalist tasks are closer to work samples than workdays. Even so, the design beats 90% of the AI-productivity claims in your LinkedIn feed: preregistered, randomized, blind-graded, with verified compliance. And because newer reasoning models handle open-ended work far better than mid-2024’s GPT-4o did, the authors argue (correctly, in my assessment) that their non-routine estimates are floors.

The Mismatch: The Workers Who Gain Most Hold the Jobs Where AI Helps Least

The bank paper’s most original contribution is a paradox. At the worker level, employees in routine-heavy jobs gained the most from AI. At the task level, AI helped non-routine tasks the most (+58% vs. +24%). Put those together: the technology delivers its biggest boost to the very people whose daily task mix exploits it least.

The authors quantify the waste. In a simulation that reassigns workers to tasks according to comparative advantage under AI, the bank’s output rises 7.3% with zero new hires and zero new software. Thus, a 7.3% raise sits in plain sight, unclaimed, because task assignments fossilized in the pre-AI era. Sprinkling chatbot licenses over an unchanged org chart captures the small win and forfeits the big one. AI adoption is a job-redesign problem disguised as a procurement decision.

Competence Glut = Commodity Work

Definition: A commodity is a product so standardized that buyers choose on price alone. One bushel of wheat equals another, and nobody pays extra for artisanal wheat.

Even wheat needed help to become a commodity. When the Chicago Board of Trade introduced standardized grain grades in 1856, “No. 2 spring wheat” from one farm became interchangeable with “No. 2 spring wheat” from any other; buyers stopped asking who grew it, and the price board took over. AI is the grading system for knowledge work: it stamps a competent grade on nearly everyone’s output, and the Siddiq and Zhang coefficients show the price board taking over hiring in real time.

For a century, professional competence was scarce, so competence commanded a salary. The studies above describe the end of that scarcity. When a $20-per-month chatbot lifts nearly any employee to a competent memo, a competent screen design, or a competent analysis, competent output becomes abundant. I call the result the competence glut: once competence floods the market, its price collapses toward the cost of the tokens that generated it. And procurement departments treat commodities the way they treat everything they can: as a spreadsheet column to minimize.

We’ve run this experiment before. In 1985, Aldus PageMaker plus the Apple LaserWriter turned typesetting, a skilled trade with centuries of guild history, into a menu command. The typesetters vanished. Demand for art direction, the judgment about what the page should say and evoke, grew. A decade later, website builders commodified the brochure site, yet UX employment expanded, because the scarce skill moved up the stack. Expect the same dynamic, at higher speed, for every deliverable-shaped profession, very much including design.

For UX, the commodity layer is already wide: wireframes, standard screen layouts, UI copy, first-draft research summaries, and journey maps now emerge at competent quality from anyone with a prompt box (we’ll get good UI quality from AI in 2027 and great in 2028; better-than-any-human-designer probably not until 2030, but 99.9999% chance that you don’t have the world’s best UX designer working on your team anyway). Design tools generate complete, styled flows from a paragraph of intent, and the output is respectable. If your professional identity is “I produce these deliverables,” you’re selling wheat, and the market-clearing price of wheat is low and dropping. What stays scarce is everything around the deliverable: knowing which problem deserves solving, whether the research question was the right one, which of 10 plausible designs will actually move conversion, and whether the feature should exist at all. When execution is a commodity, judgment is the product. Let’s make that concrete for design careers, because design shows up in the new dataset in an instructive way.

When Design Is Wheat: How UX Professionals Must Reposition

Where does design sit on the study’s exposure scale? Mid-table, officially: web and mobile design scores 0.37 on a scale where writing sits at 0.62 and translation tops out at 0.80. But the exposure yardstick was made in early 2023, and it measures only what a text-based LLM could accomplish by itself, before multimodal models and prompt-to-design tools existed. (Software development scores 0.05 on the same scale, which will amuse anyone who has watched an agentic coding tool inhale a week of programming in an afternoon.)

Visual design has since moved deep into exposed territory, which cuts both ways: the dated yardstick biases the study’s estimates toward zero, and it means designers should read the translators’ coefficients, not their own official mid-table score, as their preview. Translators topped the exposure scale, and they got hit first and hardest. Consider yourself previewed.

So take the findings personally. Three assets that UX professionals spend careers accumulating are losing purchasing power in AI-exposed markets:

• The portfolio. A gallery of polished deliverables proves less every month, because AI now produces polished deliverables on demand. When any client can generate 10 respectable landing pages before lunch, your 11th respectable landing page is evidence of nothing scarce. Verified proof of past production is depreciating because production itself is depreciating.

Retarget your portfolio to emphasize your talent for judgment. If you showcase your ability to crank out deliverables, you’re selling so much commodity wheat. (GPT Image 2)

• The credentials. Degrees, certifications, and employment history exist to predict output quality. AI compresses output quality, so the predictions matter less. A diploma still signals conscientiousness, but the market’s willingness to pay for it fell 2.4% in exposed categories and kept falling.

• The ratings. The finding that should worry freelancers most: even reputation earned inside the market through real transactions (5-star feedback, “Top Rated” badges) lost 2.9% of its hiring weight. A 5-star rating for delivering competent work stops differentiating once everyone delivers competent work.

What still moves demand? Everything the platforms can’t standardize:

• Outcomes with numbers attached. “I redesigned checkout and conversion rose 23%” is a different asset than “here are the checkout screens I drew.” The first documents judgment; the second documents production, and production is on sale.

• Proprietary user research. Fresh empirical data about how real users behave in your product is ground truth that no prompt can conjure.

• Evaluation authority. Somebody must decide which of the 10 AI-generated flows ships, and whoever holds that quality gate holds the scarce position.

• Direct relationships. Note what commoditized fastest: an anonymous marketplace where switching freelancers costs one click. Trust built with named humans over repeated engagements has no skill tag, appears in no embedding, and survives the credential discount. Friction, for once, is your friend.

One pricing warning. The Upwork data shows demand flowing to cheaper workers, and the tempting response is to cut your rate. Resist. When clients start buying on price, the worst possible response is to compete on price. You can’t out-cheap a $20-a-month subscription, and every discount confirms you’re selling the commodity rather than the judgment. Exit the wheat market; don’t become its lowest-cost farmer.

Stronger AI May Reverse the Forklift Effect

Everything so far describes current AI applied to production tasks. Will equalization and commoditization persist as AI grows more capable? My answer is no. What follows is speculation, plainly labeled: these are my predictions, and the future is under no obligation to cooperate. But the reversal keeps poking through at the edges of the data, so let’s start with the evidence.

Nicholas Otis, Rowan Clarke, Solène Delecourt, David Holtz, and Rembrand Koning gave 640 Kenyan entrepreneurs a GPT-4 business mentor on WhatsApp for 5 months (SSRN, 2024). The average effect on revenues and profits was zero. Underneath the zero sat a split: high-performing entrepreneurs gained roughly 15–20%, while low performers did about 8–10% worse. Both groups received similar advice from the AI. The difference lay in which advice each group selected and implemented. The moment the human’s job shifted from producing work to choosing among possibilities, the forklift effect flipped, and AI widened the gap instead of narrowing it.

Knowing what to lift is important, especially if you run your own business, as the Kenyan entrepreneurs in the study did. (GPT Image 2)

Medicine supplies a second data point, from the opposite direction. In a randomized trial published in JAMA Network Open, 50 physicians worked through difficult diagnostic vignettes with or without GPT-4 (Goh et al., 2024). The AI-assisted physicians diagnosed no better than colleagues using conventional references. GPT-4 alone, however, outscored both groups by roughly 16 percentage points. The machine held the answers; the humans discarded them, overriding correct AI suggestions with their own inferior ones. (Recall the law-school parallel: well-prompted GPT-4 alone also beat the AI-assisted students.) The bottleneck sat in the humans’ judgment about when to defer, and that judgment varied wildly.

Economists have now isolated this judgment factor experimentally. Andrew Caplin, David Deming, and colleagues show that two traits jointly determine who profits from AI: ability and calibration, meaning accurate beliefs about one’s own ability (NBER, 2024, since published in Management Science). Low-ability participants gained most on average, consistent with the forklift. But holding ability constant, well-calibrated people gained far more, because the overconfident ignore correct AI advice and the underconfident follow incorrect advice. Participants who knew they had low ability gained the most of all, nearly 10 percentage points, and a 2026 replication with professional radiologists reading chest X-rays found the same pattern. Knowing what the machine knows better than you is itself a skill, one that’s unevenly distributed, and nothing in the equalization studies suggests AI hands it out for free.

Anthropic’s analysis of 400,000 Claude Code sessions in June 2026 found that agentic coding compounds expertise rather than erasing it. The report documents that more experienced developers delegate differently, structure tasks differently, and extract more value per session, and it frames supervision and verification, not coding itself, as the emerging bottleneck and the emerging source of advantage.

The two main ways expertise helped in this study:

1. Leverage per prompt. In typical novice sessions, each prompt sets off about 5 Claude actions and roughly 600 words of output; expert sessions set off action chains more than twice as long (12 actions) carrying 5 times the output (3,200 words). The gap appears within every kind of work and every band of task value, and in a regression controlling for work mode, task value, month, occupation, and model family, each expertise level adds about 9% more actions and 13% more output per prompt (p < 0.001).

2. Recovery when things break. (And they do.) Among sessions that hit trouble (such as errors, failed tests, repeated attempts, or expressed frustration), verified success rose from 4% for less-skilled users to 15% for experts. And 19% of novice troubled sessions were abandoned, vs. 5–7% for everyone else. Part of the value of expertise when using advanced AI appears to be the ability to steer the agent back on course.

The mechanism is straightforward once you see it. When the AI does the raw generation, writing code stops being the scarce skill. What becomes scarce is knowing what to ask for, recognizing when the output is subtly wrong, and stitching multi-step work into something that holds together. Those are expert skills. So as the machine absorbs the easy part, the returns flow to whoever supervises well. Intelligence got cheap; judgment got expensive.

With agentic AI, expertise will be valued higher, not lower. (GPT Image 2)

All 4 results point to the same root cause: the human’s job is quietly shifting from production to selection, and selection obeys different economics. As models become agentic, running multi-step work over minutes or hours (what I’ve called slow AI), the user’s role migrates from doing the work to directing it: deciding what should be done in the first place, decomposing goals, supervising the agents, and, above all, evaluating and selecting among competing AI work products. Consider what each of those duties rewards:

• Deciding what should be done is the scarcest skill of all. Peter Drucker warned that nothing is quite so useless as doing efficiently what shouldn’t be done at all. An agent swarm executing the wrong strategy produces impeccable waste at record speed. Problem selection has always separated great professionals from good ones, and agents multiply the price of that separation.

• Evaluation becomes the new production. Picking the best of 10 AI drafts requires the taste to tell which one is best, and judgment correlates brutally with experience and talent. In Kenya, low performers couldn’t filter good advice from merely plausible advice. A junior designer facing 10 gorgeous, subtly wrong AI mockups sits in the same trap: he or she can generate infinitely, and the bottleneck is knowing what to keep. The central-bank study already whispers this message, since the biggest winners on the hardest tasks were high-skill employees who knew both the domain and the tool.

• Leverage amplifies judgment in both directions. A person directing 50 tireless agents multiplies every decision 50-fold, good and bad alike. Management has never equalized outcomes among managers; get a team of 10 underlings to work for you, and the results magnify every difference in management skill. Handing everyone an agent workforce amounts to promoting everyone to manager, and most people have never managed anything.

The supervision era has already been piloted at scale, and the early data supports this argument. In August 2024, Alibaba ran a randomized field experiment on Taobao in which 647 customer service workers either handled every chat themselves or supervised an agentic AI that autonomously resolved eligible chats, intervening when needed (arXiv, 2026; 680,676 chats).

The agentic AI cut chat time, but outcomes hinged on the quality of human oversight. When supervisors used their own judgment to step in early, before customer frustration hardened, they resolved issues at least as reliably as all-human service. When they instead waited for the monitoring algorithm to sound the alarm on an emotionally deteriorating chat, quality cratered: customer ratings fell 0.9 points on a 5-point scale, repeat contacts rose 6 percentage points, and the transcripts show the workers half giving up. Same AI, same tasks; the differentiator was the supervisor’s timing and judgment. (A pleasant side effect: with routine chats offloaded, the same workers’ ratings on the judgment-heavy chats they kept handling went up.) Oversight, it turns out, is a skill with a distribution, exactly like the production skills it’s replacing.

Return to the warehouse one last time. A forklift narrows the strength gap because nearly anyone can drive one after a 2-day certification course. A 100-meter tower crane is a different machine: its operator is licensed, scarce, and well paid, because the crane’s power multiplies the cost of every operator error. The stronger the machine, the more the operator’s judgment matters. Today’s chatbots are forklifts. Agentic AI is a crane.

While first-generation AI products were indeed the equivalent of forklifts in narrowing skill gaps, second-generation AI in the form of agentic products may be more similar to a crane which only works in the hands of a skilled operator. (Muse Image)

Now connect the prediction back to the Upwork data, and notice what the platform cannot see. Profiles carry skill tags for Python, Figma, and legal translation, but there’s no skill tag for “knows what to build,” no star rating for “kills bad projects early,” and no badge for taste. The market just repriced every signal it can see; the signal it will need next doesn’t exist yet. I predict that within 2–3 years, labor marketplaces will scramble to invent judgment signals, such as outcome-verified case histories (did the freelancer’s decisions move the client’s metric?), because a market that differentiates only on price is in a margin death spiral, bad for workers and platforms alike. Watch for the human capital coefficients in follow-up studies to bottom out, and for a new premium to appear, attached to direction rather than production.

Of course, one counterargument deserves airtime: judgment itself may eventually commodify. In freestyle chess, human-plus-engine teams beat engines alone for roughly a decade after Garry Kasparov introduced the format in 1998; today, the human teammate is a liability. (The only way to win in chess is to play the exact move the AI suggests. Any human judgment, and you lose.) If AI evaluators someday out-judge expert humans across professional work, the judgment premium becomes a historical window rather than a permanent moat. My best guess: the window stays open through at least 2030 for work embedded in messy human organizations, where goals are political, data is ambiguous, and accountability must land on a person with a name. Enjoy the window, and don’t plan your retirement around it.

So here’s my forecast: current AI narrows skill gaps in producing work; future AI will widen skill gaps in directing work. The equalization studies of 2023–2025 measured AI as a better pen. Agentic AI is a workforce, and workforces have always paid a premium to the people who know what to build.

Takeaways for Corporate Strategy

1. Reallocate people as well as licenses. The central-bank simulation found 7.3% more output from reassigning tasks by comparative advantage under AI, with zero additional spending. Redesign task assignments and job descriptions around what AI changes. A chatbot bolted onto a 2019 org chart collects a fraction of the available value.

2. Onboard the bottom, and train the top. Basic adoption support raises the quality floor for weaker staff, which the equalization studies all but guarantee. But the largest absolute gains in the bank came from experts applying AI to hard specialist tasks, which required domain skill plus prior AI experience. Budget for both programs; they aren’t substitutes.

3. Stop paying a premium for commodity competence, and stop buying judgment at commodity prices. If AI lifts everyone to the same competent level on a task, its market price will fall regardless of anyone’s feelings; the Upwork clients have already started the repricing for you. But run the logic in both directions: procurement that selects a design or research partner on day rate alone will reliably buy wheat and then wonder why the strategy tastes bland. Sort purchases into commodity and judgment lanes, and price-shop only the first.

4. Rebuild the apprenticeship ladder before it rots. Juniors traditionally learned judgment by grinding through the commodity work that AI now performs. Replace that lost training ground deliberately: structured critique, shadowing senior evaluators, and graded review of AI output. Otherwise, in 10 years you’ll wonder where the senior people went.

If we remove the bottom rungs from the experience ladder, we won’t have any senior staff in 10 years. (GPT Image 2)

5. Measure quality and speed separately. The bank found the two gains uncorrelated across employees. Track only throughput, and you’ll miss quality regressions; track only quality, and you’ll miss the people burning hours to polish commodity output. Set explicit targets for each.

6. Build the evaluation function now. Someone must specify, verify, and sign off on agent output at scale. Rubrics, sampling audits, and named accountability are the new production infrastructure. Companies that treat verification as overhead will ship impeccable waste, faster than ever.

Takeaways for UX Professionals

1. Sell outcomes and decisions, not deliverables. A wireframe is wheat, and the new data says the portfolio displaying it trades at a growing discount. Knowing which design will lift conversion, and being able to prove it with data, is the product. Restate your role, your case studies (fewer artifacts, more decisions with measured consequences), and your job postings accordingly.

2. Claim the evaluation layer. UX is the discipline of judging fitness for human use, which makes it the natural quality-control function for AI-generated everything: screens, flows, copy, and agent behavior. Volunteer to own the rubrics. Whoever grades the work governs the work.

3. Make original user research your moat. AI remixes what’s already known, and it can’t watch your users tomorrow. Fresh empirical data about real behavior is proprietary ground truth and the raw material of the judgment you’re selling. Watch users, not model outputs. (In my example: anybody can generate a photo of a cute dog. Only UXR can produce a picture of the company’s actual customers, whether dogs or not.)

4. Train taste on purpose. Judgment used to accrete accidentally through years of production work, and that path is closing. Build it deliberately: regular design critiques, exposure to excellent and terrible work, and prediction exercises scored against real usability-test results.

5. Practice directing agents. Move beyond single prompts to specifying, decomposing, and supervising multi-step AI work. The UX professionals who thrive will run a portfolio of AI workers the way a creative director runs a studio.

6. Specialize in a domain. The bank’s specialist tasks delivered the largest gains, and only domain experts could harvest them. Deep knowledge of fintech, health, enterprise workflows, or another vertical multiplies what AI does for you and resists commodification far longer than generalist skills will.

You need to move beyond commoditized production skills if you want to sell your portfolio to hiring managers. (GPT Image 2)

Conclusion: The Forklift Doesn’t Know What to Lift

The forklift transformed the warehouse twice. First, it equalized: strong and weak workers moved identical pallets, and strength stopped paying. Second, and more quietly, it shifted the money to the people who decided which pallets went where, because a warehouse that moves the wrong goods quickly is merely an accelerated mistake.

A warehouse that moves low-value products fast will still lose money, even with AI forklifts. (GPT Image 2)

AI is running the same 2-act play on knowledge work, only faster. Act 1 is here: skill gaps narrow, competence gluts the market, and deliverables commodify. The 9 experiments in this article confirm it, and 2.26 million contracts show buyers acting on it: credentials trade at a discount, and demand flows to the cheapest competent bid. Act 2 arrives with agentic AI: leverage flows to the people with the judgment to decide what should be built and the taste to select the best of what the machines produce. Position yourself, and your organization, for the second act while everyone else is still applauding the first.

Have you watched AI compress skill gaps on your team, or watched clients start shopping on price? I welcome your observations. And remember the limit of the machine that started this argument: the forklift lifts anything you point it at, but the forklift doesn’t know what to lift. That job is still yours. Keep it.

Forklifts are good at lifting but don’t know what to lift. Similarly, with agentic AI, somebody needs to be the equivalent of the factory founder and decide what should be done. (Muse Image)

About the Author

Jakob Nielsen, Ph.D., is a usability pioneer with 43 years experience in UX and the Founder of UX Tigers. He founded the discount usability movement for fast and cheap iterative design, including heuristic evaluation and the 10 usability heuristics. He formulated the eponymous Jakob’s Law of the Internet User Experience. Named “the king of usability” by Internet Magazine, “the guru of Web page usability” by The New York Times, and “the next best thing to a true time machine” by USA Today.

Previously, Dr. Nielsen was a Sun Microsystems Distinguished Engineer and a Member of Research Staff at Bell Communications Research, the branch of Bell Labs owned by the Regional Bell Operating Companies. He is the author of 8 books, including the best-selling Designing Web Usability: The Practice of Simplicity (published in 22 languages), the foundational Usability Engineering (31,140 citations in Google Scholar), and the pioneering Hypertext and Hypermedia (published two years before the Web launched).

Dr. Nielsen holds 79 United States patents, mainly on making the Internet easier to use. He received the Lifetime Achievement Award for Human–Computer Interaction Practice from ACM SIGCHI and was named a “Titan of Human Factors” by the Human Factors and Ergonomics Society.

· Subscribe to Jakob’s newsletter to get the full text of new articles emailed to you as soon as they are published.

· Follow Jakob on LinkedIn.

· Read: article about Jakob Nielsen’s career in UX

· Watch: Jakob Nielsen’s first 41 years in UX (8 min. video)

Summary: AI use becoming more localized, according to Gemini data from Southeast Asia | Heavy AI use in a company increases hiring, not layoffs | Winners of the AI Film Festival awards | The inventor of hypertext, Ted Nelson | Helping users recover from errors | AI drones help replant the rainforests | Annotations seem a simple feature, but are often designed wrong | Token use is going through the roof with agentic AI

UX Roundup for July 20, 2026 (GPT Image 2)

AI Goes Native in Southeast Asia: 70% Local Languages, 42% No Keyboard

Google released The Gemini Report: Southeast Asia on July 14, 2026, analyzing aggregated usage data from millions of Gemini conversations across 6 countries: Indonesia, Malaysia, the Philippines, Singapore, Thailand, and Vietnam. Active users in the region more than doubled in a year. Two findings deserve attention far beyond Southeast Asia.

AI Speaks the User’s Language

Nearly 70% of prompts in Southeast Asia are submitted in local languages, not English. Vietnam leads at a whopping 89% Vietnamese, followed by Thailand (87% Thai) and Indonesia (84% Bahasa Indonesia).

For the first 40 years of personal computing, the machine spoke English and everybody else adapted. Chinese and Japanese character sets weren’t supported at all, and I remember the contortions needed to use even the modest requirements of the Danish language, with its three extra characters Æ, Ø, and Å. (Luckily, I can now use Danish characters easily thanks to Unicode, though my ancestors’ runes still render correctly only in special fonts like Segoe UI Historic.)

Odin and his ravens Huginn and Muninn, made with Reve 2.1. While the god’s outfit looks Viking enough to be historically plausible, the three names are not rendered with correct runes, whether Elder Futhark, as I requested, or the Younger Futhark you sometimes see.

Menus, commands, and error messages shipped in English first, with localization as a grudging afterthought that arrived a year late and read like it. AI reverses the polarity: when the interface is natural language, “natural” means the language the user thinks in, and a student in Hanoi has no reason to compose his or her homework questions in English. (AI Singapore’s SEA-HELM benchmark rated Gemini the best large language model for Southeast Asian languages, which surely helped Google’s numbers. Vendors that treat Thai or Vietnamese as second-class languages will forfeit these markets.)

The Keyboard Becomes Optional

42% of prompts use voice, camera, or image input instead of typing. Users snap a photo of a homework problem, a plant, or a menu, or they simply talk. Seniors in Thailand show the highest multimodal adoption of any age group. That makes sense: people who never became fluent typists skip the keyboard entirely, just as emerging markets skipped landlines and went straight to mobile phones.

I predict this 42% will grow. Text was never the natural human interface; it was a workaround for machines that couldn’t hear or see. Now they can. OpenAI launched GPT-Live on July 8: full-duplex voice models that listen and speak simultaneously, murmur “mhmm” while you talk, and wait politely when you pause to think. Full-duplex kills the walkie-talkie rhythm that made older voice modes feel like leaving messages on an answering machine. As speech turns into genuine conversation and the camera becomes the AI’s eyes, keyboard-optional computing will spread from Southeast Asia to your users too.

The obligatory caveat: this is vendor research about the vendor’s own product, so discount the self-congratulation. But the behavioral data covers millions of real users doing real tasks, which beats any survey of what people claim they do.

UX Implications

• Stop designing English-first. Test your AI features with native-language prompts, including the code-switching common in some countries (Taglish blends Tagalog and English mid-sentence). If quality drops outside English, most of your Asian users get the degraded product.

• Promote voice and camera to first-class inputs. They aren’t accessibility extras anymore. Give them prominent entry points on the main screen, and make sure results render sensibly when the query was a photo rather than a sentence.

• Design for conversation, not dictation. Full-duplex speech makes interruptions, backchannels, and turn-taking part of your design material. Users will cut the AI off mid-answer. Plan for it.

• Test with the keyboard turned off. Run your next usability study with typing banned. If the design collapses, so does its appeal to 42% of this market.

So the region often described as mobile-first is now previewing the AI-first interface: spoken, visual, and multilingual. The keyboard had a good 150-year run. It can start planning its retirement party.

Deep AI Adoption = 10% More Jobs

Companies that spend serious money on AI hire more people, not fewer. That’s the headline from A New Look at AI’s Impact on Jobs by Ara Kharazian and Ryan Stevens of the payments platform Ramp, together with Lisa Simon of the workforce-analytics firm Revelio Labs. It’s the first study to connect firms’ real AI invoices with their headcount records at scale, covering 21,559 U.S. firms. The heaviest AI spenders grew total employment by 10% in the 24 months after adoption, and their entry-level headcount rose 12%. Light spenders got nothing.

The data is the star of this paper. Ramp processes corporate card and bill payments, so the authors could see exactly which firms pay AI vendors, how much, and when, with no surveys, no occupational “exposure” indices, and no executives flattering themselves about their company’s AI sophistication. Revelio Labs tracks monthly employment from millions of public career profiles. A firm counted as an adopter once it paid AI vendors at least $100 per month for 3 straight months, a threshold that filters out one-off employee experiments. The authors then split adopters by early spending intensity: the top third averaged $33.67 per employee per month, while the rest averaged $2.78. That’s 12 times the money, and the multiple turns out to be everything.

“AI use” is not a binary choice. Companies that just use a little AI sprinkled here and there don’t hire new staff. Companies with intense AI use are the ones that grow. (GPT Image 2)

The gains follow a learning curve. Heavy adopters showed zero extra growth in the adoption month, about 7% by month 6, and roughly 32% by month 18. So the technology didn’t pay off on day one: firms apparently need 6–12 months to find use cases and rewire workflows before AI funds expansion. And the hiring was broad: sales up 10%, administration up 8%, engineering up 7%, customer service up 6%. By sector, though, the party remains exclusive: Information firms (software, internet, media) grew about 13%, the only sector group with a statistically significant gain so far, which fits the head start that coding agents enjoy over every other commercial AI use case.

Staff growth from heavy AI use doesn’t happen the day the company turns on the AI spigot. Things take time, and the strongest employment effect takes more than a year, happening at the 18-month mark. (Muse Image)

Doesn’t this contradict the Stanford “canaries in the coal mine” study, which found employment down roughly 16% for workers aged 22–25 in the most AI-exposed occupations? No. The Stanford team measured occupations across the entire economy, whereas this study measures individual firms that adopted. Both results can hold at once: deep adopters hire juniors while grabbing market share from laggards who shed them. What happens to national employment is exactly what a firm-level study can’t tell us.

Now for the salt. This is vendor research: The sample skews toward tech-forward, mid-market firms that chose a fintech card platform. Adoption is also self-selected: the firms that eventually bought AI were already growing 6% a year before they spent a dime, versus 1.6% for never-adopters, so part of what we’re watching is winners buying tools rather than tools creating winners. The authors handle the problem better than most by comparing early adopters only with similar firms that adopted later, which aligns the pre-adoption growth paths. Still, payment records beat surveys, where executives claim AI adoption that never shows up on an invoice.

Pick Employers That Do the AI Reps

Most firms practice gym-membership AI: they pay the subscription and skip the workouts. (The gym doesn’t mind; it already has your money.) The employment gains in this study went to the firms doing the reps: coding agents, API budgets, multiple vendors, roughly $34 per employee per month instead of $3. Three consequences for your career planning:

• Screen employers by AI intensity. In your next job interview, ask what AI tooling the team pays for beyond chat subscriptions. A concrete answer about agents and APIs signals a firm on the 10%-growth track; “we all have ChatGPT seats” signals a $3 shop.

• Junior talent should target heavy adopters. Entry-level headcount rose 12% at these firms, the opposite of the doom narrative. If you’re early in your career, the companies using AI the most are the safer bet.

• Distrust AI-blamed layoffs. When a CEO attributes job cuts to AI, this data suggests you check whether the real story is slowing sales. The authors put it plainly: be skeptical.

Productivity gains create new work; they don’t exhaust a fixed pile of it. That’s the fixed-work fallacy I skewered back in 2023, and the payment records of 21,559 firms now back me up, at least for the early adopters. Don’t run gym-membership AI in your own career, either. Do those reps.

Just as with fitness, repetition is key to AI progress. Keep working out, and you’ll see the gains. (GPT Image 2)

Award-Winning AI Short Films

The winners of the 2026 Runway AI Film Festival awards have been announced (scroll down the linked page to see the list, with further links to watch each winner on YouTube).

The two top winners are indeed excellent films that you can enjoy watching on their own merits, without caring that they were made with AI. That’s obviously the long-term goal, even though right now, we also watch AI videos to appreciate the technical advances each new crop showcases.

Grand Prix winner: A Face Only a Mother Could Love by Robert Gaudette (8 min.). The tribulations of an extremely ugly man who finds love in the end. The moral of the story is trite (there must be thousands of tales making the point that outer beauty is not what’s most important), but it’s told well enough that I don’t mind. Wonderful character design of the ugly man, including how he looked as an ugly boy.

Gold Medal: The Well by Dorian & Daniel (5 min.). A murder mystery set in a fantasy world of anthropomorphic animals. I won’t spoil the film by revealing which animal is the killer, but the victim is a wolf, which runs counter to the stereotypes of traditional fairy tales. The detective story is decent enough, but the characters drive the film.

Both films have decent stories that do engage the viewer, but I would say the character design makes the difference between good and great. The ability to design and animate characters that don’t exist in the real world is a trademark of AI movies, even though legacy movies sometimes achieve similar results with masks and prosthetics.

Character design wins the day in current AI movies. (GPT Image 2)

All the runner-up awards (listed on the Festival page) disappointed me, as they were in the style of countless boring and pretentious film-school student projects. (I don’t know if those filmmakers were, in fact, film school students, but I have seen enough short “art” movies to recognize and despise the genre.)

On the one hand, I agree with the award judges’ selection of the two winners: these two short films were clearly the best. On the other hand, unless the unrewarded films were all complete sludge, the judges were hoodwinked by pretentiousness instead of recognizing engaging storytelling.

We don’t need AI to produce more boring art films. Stop rewarding pretentiousness. No more film-school-envy. Create something people want to watch, whether the old gatekeepers look down on it or not. (GPT Image 2)

From a technical perspective, the Japanese Between Before and After and the Korean Divine Retribution both featured impressively photorealistic human characters, and the Japanese AI actors even “acted” well (i.e., were convincingly animated), as far as I could judge while watching the movie with subtitles without understanding what was said.

While I didn’t like the stories in the photorealistic AI movies, the AI actors seemed just as good as human actors, showing what’s already possible in the hands of a skilled AI director. (GPT Image 2)

Overall, a disappointing catch, but finding two great films made the festival worth my time. The films are being screened in Tokyo on July 30 if you’re in town.

Is AI ready to produce full-length feature movies? Probably not. The 5–8 minute running length of the two winners is likely the current maximum, and I think the longer of the two shorts would have benefited from being one or two minutes shorter.

Hypertext Hero: Ted Nelson

In my series of UX heroes, we have come to Ted Nelson, who was more of an eclectic hippie than a scientist or designer. Nelson invented hypertext, which is the basis for the World Wide Web, though he has complained that the Web didn’t implement all of his ideas.

Ted Nelson invented hypertext as a concept, but the main practical implementation of his ideas, the Web, didn’t live up to his vision. (GPT Image 2)

For me, Ted Nelson holds a special place, as he inspired me to become a UX expert specializing in the usability of hypertext and online information, which in turn prepared me perfectly to develop guidelines for usable web design. In particular, I read Nelson’s pioneering 1974 book Dream Machines around 1980, when I was casting about for a thesis topic, and even though the book was already about 6 years old, it was so revolutionary that it inspired me to pursue similar research.

Here is a comic strip (made with GPT Image 2) where my characters Alice and Zimo meet Ted Nelson, who takes them through Dream Machines and how his vision was partly realized by the Web:

Ted Nelson’s Dream Machines was a riotous scrapbook of ideas that anticipated much of the modern Web while diverging sharply from it.

Nelson’s central thesis was that technology expresses human dreams, and that computers are not calculating devices but “dream machines” for ideas, fantasy, and expression, continuous with cinema and literature. (Seems obvious now, but was radical then, which is what inspired me so much.) His insistence that computer experiences are media to be designed prefigured today’s UX and interaction design. The Web partly fulfills this as a general medium for text, image, sound, and video, though its commercial drift toward advertising and engagement optimization narrows a vision that was more literary and civic.

He argued against institutional mainframes (the dominant computers at the time) in favor of small, personal, interactive computers as creative tools. The Web rode exactly this shift toward personal and networked machines. Nelson’s populist goal (anyone could publish and anyone could read) closely matches the early Web’s self-image, though Tim Berners-Lee implemented a simpler, pragmatic version rather than Nelson’s rigorous structures. (Which is why Sir Tim’s project actually worked and he got a knighthood.)

The conceptual spine is hypertext: non-linear, interlinked text and media. Nelson coined terms for chunk-style hypertext (discrete units joined by links), stretch text (text that expands in place), and intertwingularity (the claim that everything is deeply interconnected). The Web almost perfectly realizes chunk-style hypertext. Stretch text survives only as ad hoc progressive disclosure, accordions, and “read more” toggles, never standardized. Intertwingularity underpins search engines, PageRank, and knowledge graphs, though without Nelson’s demand for curated, meaningful links.

Nelson’s “fantics,” the art and science of conveying ideas emotionally and cognitively, foreshadowed debates about persuasion, dark patterns, and the rhetoric of interfaces. He also imagined branching movies and interactive cinema; these remain niche, surviving mainly in interactive episodes, games, chapter markers, and time-coded links rather than as a core Web primitive.

Xanadu, his formal publishing proposal, began in 1960, marking the sharpest divergence between ideal and reality. It specified bidirectional links, transclusion (quotations virtually included from sources), fine-grained version management, and built-in rights and micropayments. The Web instead adopted cheap, unidirectional links, fueling explosive growth but sacrificing provenance, link robustness, and scholarly traceability. Wikis, Git, and Creative Commons emulate fragments of Xanadu at higher layers.

Nelson also championed non-linear learning environments and an anarchic, populist publishing network resistant to gatekeepers. The open Web, MOOCs, and the early blogosphere embodied this, yet activity has since gravitated toward large platforms and closed ecosystems, partly realizing his fears about centralization.

Seen from 2026, Dream Machines is not a failed blueprint but a rich design space from which the Web took only thin slices, chiefly chunk-style hypertext and democratized publishing, while leaving aside the structural, epistemic, and rights-related ambitions that would have demanded far greater complexity and global coordination.

Error Recovery

Errors happen. Even the best-designed systems can’t prevent every mistake, which is why my ninth usability heuristic, Help Users Recognize, Diagnose, and Recover from Errors, matters so much. (See all 10 usability heuristics in infographics, with design patterns to use and to avoid.)

Of that heuristic’s three verbs, recover is the one that pays. When something goes wrong, users should never feel stranded. Strong error recovery starts with messages written in plain human language rather than cryptic system codes. Tell people exactly what happened and where, highlighting the specific field or step that needs attention.

Then give them a clear way forward. Offer retry buttons so a single tap can fix the problem. Show format examples so users know precisely what’s expected. Provide alternative routes when the first path fails. The goal is to solve the problem, not merely announce it.

Good recovery design turns frustration into confidence. Users who can quickly correct their course and continue will stay engaged, instead of abandoning the task. They learn to trust that mistakes are reversible and that the system has their back.

So when life spills, refill. Design experiences that catch users when they stumble and guide them smoothly back on track. That’s usability working exactly as it should.

Error recovery builds usability. (GPT Image 2)

AI Drones Help Replant the Rainforests

My prediction 16 for 2026 was “Physical AI: The Brain Gets a Body,” which I scored as having come a little more than half true (58%) in the midyear assessment of my 2026 predictions. I came across a new example that would add to this score: MORFO is a French–Brazilian “full‑stack” reforestation startup that uses AI‑guided drones and custom seed capsules to restore degraded forest ecosystems at large scale, especially in Brazil and parts of Africa.

The AI brain gets a flying body. Physical AI indeed. (GPT Image 2)

Before any seed is dropped, MORFO runs an ecological and spatial analysis pipeline.

• Field and lab data: Soil samples, on‑the‑ground surveys, and local botanical knowledge feed a species catalog and constraints for each site.

• Remote sensing: Satellite and high‑resolution drone imagery map topography, moisture, canopy gaps, existing vegetation strata, and degradation patterns.

• AI modeling: Machine‑learning and computer‑vision systems help identify priority micro‑sites, suitable species mixes, and planting densities, and later track biomass growth, biodiversity indicators, and carbon stocks over time.

The result is a planting scheme that doesn’t simply maximize “trees per hectare” but distributes different species according to soil type, slope, water availability, and succession dynamics, effectively encoding a designed forest architecture that drones then execute.

Human planners only have the brainpower to handle large areas as an undifferentiated whole, whereas AI can keep thinking cheaply and construct new plans for every tiny plot of land, accounting for local variations. (GPT Image 2)

Drone Seeding Mechanics

MORFO uses agricultural‑grade drones, roughly 1.5 meters in diameter, equipped with custom release mechanisms and loaded with several thousand seed capsules per flight.

• Seed capsules: Each capsule contains pre‑germinated native seeds plus protective microorganisms and substrates, tailored to local conditions; multiple species can be combined to create micro‑assemblages.

• Throughput: A single drone can plant about 180 seed capsules per minute and cover up to roughly 50 hectares in a day, making it 20–100 times faster than manual planting and up to 5 times cheaper when nursery and logistics costs are considered.

The AI drones vastly outperform traditional planting methods, meaning that more plants get into the ground. (GPT Image 2)

• Access: Drones can operate on steep, post‑fire terrain and remote Amazonian or Sahelian sites that are difficult or unsafe for people, opening up restoration in areas that would otherwise remain untouched.

It’s just as easy to fly over nasty terrain as over flat ground, meaning that the AI drones easily replant a larger area. (GPT Image 2)

In Rio de Janeiro’s hills, for instance, drones drop capsules over hard‑to‑reach slopes above the city, following AI‑defined flight paths and planting patterns while municipal authorities provide site selection and regulatory support.

Human–Machine Collaboration and Outcomes

MORFO is explicit that drones augment, rather than replace, human ecological work: botanists, soil scientists, and local stakeholders define species choices and restoration goals, while pilots operate drones and teams conduct ground‑truthing and long‑term monitoring. Drones then serve as scalable actuators for an already‑designed ecological plan, and as repeatable sensing platforms for tracking biomass, biodiversity, and carbon over the years.

Early results from various Amazon sites suggest that thousands of hectares of degraded land can be put on a recovery trajectory more quickly than with conventional sapling‑based reforestation, though the long‑term ecological performance still depends on classic factors like species selection, climate stress, and socio‑political protection against renewed deforestation.

My conclusions from this project:

· AI is moving far beyond the chatbot stage. Not just getting a body, but a flying body.

· AI makes things cheaper, which means that they get done. Instead of talking about the rainforest, it replants it.

As we say in Silicon Valley: “you can just do things.” AI often makes worthy things so cheap that they actually get done instead of being the topic of endless discussions. (GPT Image 2)

· AI allows sophisticated analysis at scale: for example, dropping an optimized selection of seeds for each micro-plot, which produces a more viable replanted ecosystem than a predetermined seed mix.

Cognition at scale means AI drones can plant optimal seeds in every small area. Something that could never be done by expensive human planning. (GPT Image 2)

Annotations: A 1,000-Year-Old Pattern That Software Keeps Fumbling

An annotation is a note with an address: commentary anchored to the exact spot it concerns. That anchoring is why margin comments beat every detached feedback channel for precision, and it’s also the pattern’s weak joint: when content changes or notes pile up, the annotation layer decays into crust that buries what it was meant to illuminate.

Marginalia, the ancestral annotation system: every note pinned to the exact passage it explains. Scribes ran this design pattern for 1,000 years without a single sync conflict. (GPT Image 2)

Definition: An annotation is user-added commentary (a comment, highlight, correction, tag, or drawing) attached to a specific location within a piece of content, such as a text span, an image region, a video timestamp, or a spreadsheet cell.

Every annotation has two parts: the body (what you say) and the anchor (where it applies). The W3C Web Annotation Data Model, a formal web standard since February 2017, codifies precisely this body-plus-target structure. Remove the anchor and you no longer have an annotation; you have a detached comment, floating free of context, forcing every reader to reconstruct what “this is wrong” refers to. (Spoiler: half of them reconstruct it differently.)

From Monastery Margins to Microsoft Word

The pattern predates software by roughly a millennium. Medieval scribes filled manuscript margins with glosses explaining difficult words and disputed doctrine, and the Talmud institutionalized the layout: core text in the center of the page, ringed by layers of commentary accumulated across centuries. Mathematics owns the most famous annotation of all: in 1637, Pierre de Fermat jotted in his copy of Diophantus that he possessed a marvelous proof too large for the margin. Supplying that missing body took 358 years. Insufficient margin width is, evidently, a usability problem with a long tail.

Digital tools adopted the pattern early. Microsoft Word shipped comments and revision marks in the early 1990s, embedding annotation into office life. The web then supplied a governance lesson: Third Voice (1999) let anyone paste sticky notes onto any website, publishers erupted at seeing rival commentary overlaid on their pages, and the service was dead by 2001. Google Docs later made anchored margin comments the default way office documents get reviewed, and the 2017 W3C standard gave the pattern formal plumbing for interoperability.

Why Annotations Work: The Anchor Carries Half the Meaning

Catherine C. Marshall of Xerox PARC published the field’s foundational study in 1997, examining the markings students left in used university textbooks. Two findings still steer design today. First, annotations serve future readers, not only their authors: students shopping for used textbooks favored copies whose previous owners had marked them up helpfully. Second, the tool shapes the behavior: highlighter-wielding students wrote fewer margin notes than pen users, because producing legible words with a highlighter is a chore. (Methodology note: this was qualitative fieldwork on paper artifacts, with superb ecological validity; these were real marks made by real students with no researcher hovering nearby.)

Why does anchoring matter so much for collaboration? Consider the alternative, verbal addressing: “third paragraph on page 6, second sentence, the clause after the comma.” Every such description costs the writer effort, costs the reader a search, and breaks the moment anyone edits the document. An anchored comment costs one click and points with pixel precision. Proximity also cuts short-term memory load, since the reader sees the claim and the critique side by side instead of juggling two windows. Do what the medieval page did. Keep commentary next to its subject.

How Annotations Fail: Annotation Crust

Annotation systems fail slowly, by accumulation. This results in annotation crust: the hardened layer of stale threads, resolved-but-never-closed comments, duplicates, and orphaned notes that encases a document until nobody reads any of it. Crust forms through 4 mechanisms:

• Orphaned anchors. The content changes, and the note now points at nothing, or silently at the wrong thing, which is worse. Robust systems re-attach anchors using the surrounding context and visibly flag the ones they cannot rescue.

• Occlusion. 40 pins on one screenshot means the map has covered the territory. Collapse markers at high densities, and let users toggle the whole annotation layer with one keystroke.

• Notification floods. Every comment pinging every collaborator converts a useful layer into a mute-me machine. Batch updates into digests once a thread heats up.

• Privacy accidents. A user may believe the note is private, but it is visible to the entire workspace. Awkwardness follows, or lawsuits. State the audience at the moment of writing, right beside the input field, not in a settings page three screens away.

None of this argues against annotations. It argues for treating them as a managed lifecycle rather than a bottomless pile.

9 Design Guidelines for Annotation Features

1. Anchor precisely. Attach notes to the exact span, region, timestamp, or cell, never to the whole document, because “somewhere in here” helps nobody.

2. Show the anchor with the body. Quote the annotated excerpt inside the comment panel and in notifications, so the note makes sense even out of context.

3. Survive edits gracefully. Re-anchor using surrounding text when content changes, and flag orphaned notes explicitly instead of deleting them without a trace.

4. Give every annotation a lifecycle. Open, resolved, archived. Hide resolved threads by default, and let users purge the archive.

5. State visibility at creation time. A label such as “Visible to everyone in this document” beside the input field prevents the worst annotation accidents.

6. Make the layer toggleable. One keystroke should hide every note so the content itself can be read clean.

7. Batch the notifications. Send digests rather than a ping per comment once activity passes a few events per hour.

8. Support filtering. By author, status, and date; a reviewer returning after a week needs “what’s new” in one click.

9. Keep annotations subordinate to the content. Margins, collapsed pins, and hover reveals; the moment the notes visually dominate the material they describe, the crust has won.

Send Notifications Through the More Available Sense

Smart glasses can interrupt you through your eyes or your ears. Which should they pick? New research from Dinithi Dissanayake, Prasanth Sasikumar, and Suranga Nanayakkara at the National University of Singapore’s Augmented Human Lab answers: whichever sense happens to be less busy at that moment (HeadRoom, arXiv preprint, July 2026).

Their system estimates the moment-to-moment “availability” of the visual and auditory channels straight from a wearable’s egocentric camera and microphone. The trick borrows from predictive-coding neuroscience: a sensory stream that’s hard to predict is a stream the brain is already working hard on. Two tiny self-supervised predictors forecast the next video-frame embedding and the next audio-feature vector, and high prediction error flags an occupied channel. The full model weighs a mere 0.625 MB and runs in 11 ms per step on a Meta Quest 3S headset, so it’s deployable on today’s wearables with no cloud round-trips. Think of it as Christopher Wickens’s Multiple Resource Theory from the 1980s, finally productized at the edge.

Multiple Resource Theory is rarely used in user interface design practice, because few systems are truly multimodal. The experimental smart glasses UI from Singapore used the theory to save users a tenth of a second. Doesn’t sound like much, but in use cases such as air traffic control or military applications, that time can be the difference between life and death. (GPT Image 2)

The evaluation: 22 participants (25 recruited; 3 excluded for missing the 80% detection bar) watched three 6-minute egocentric videos in a headset while responding to 200 ms flashes or 1 kHz tones, routed to the predicted better channel, the predicted worse channel, or randomly. In the calm scenes, routing didn’t matter. But in the high-demand scene (dynamic motion plus concurrent speech, with video comprehension accuracy dropping to 50%), misrouted probes cost 114 ms in response time compared with correctly routed ones, a large effect (d = 1.3). Meanwhile, subjective NASA-TLX workload ratings showed no differences across conditions: behavior registered what self-reports missed. Watch what users do, not what they say.

Caveats: model-based routing didn’t significantly beat random routing, so the proven effect is avoiding the worst channel, not divining the best one. And detecting a beep is far easier than absorbing a calendar alert or an agent’s status report. Fair enough for a first controlled study.

Why this matters: agentic AI will multiply notifications, because agents working in the background must report back on finished tasks, exceptions, and approvals. Interruption design thus becomes a core UX problem, and output modality should be a runtime decision driven by the user’s perceptual budget rather than a settings checkbox. I predict attention-aware routing will ship as a platform service in mainstream wearables within 5 years. Notifications that knock on the open door feel polite. The rest are sensory spam.

Token Use

This weekend, I used Fable 5 in agentic mode on Max setting in Cowork to do a literature review. The agent ran for 8 hours (talk about slow AI) and did produce a nice lit review. However, it consumed 4.7 million tokens in this small project, which would have cost $235 if charged at Anthropic’s list prices for API use.

Luckily, I used Fable on a subscription plan, and it “only “ used up 50% of my weekly rate limits on this run. Since the monthly subscription is $200, the 4.7 M tokens equate to around $25. That estimate assumes that I max out the subscription every week, which I’ll probably do this week, since I’ve already used up 57% for this lit review and a few smaller projects. In general, I don’t go up to the rate limits, so a more realistic estimate is that I spent maybe $35 worth of a month’s subscription fee on this one agentic AI run. Even when getting huge discount with a subscription compared to the by-the-token API charges, frontier AI is getting expensive.

I may be turning into a token whale now that I’m addicted to Fable 5 with max reasoning. (GPT Image 2)

Conclusion: The Machine Finally Adapts to the Human

Eight stories, one arc. For the first 40 years of computing, the human did the adapting: typing English at machines that spoke nothing else, deciphering error codes, memorizing which menu hid which command. This week’s stories show the adaptation burden switching sides. It was my lifelong goal and motivation for specializing in usability to make technology suitable for humans instead of requiring humans to bend over for the machines. I’m happy this is finally happening.

Gemini answers a student in Hanoi in Vietnamese. GPT-Live waits for you to finish a thought. HeadRoom’s smart glasses check which of your senses is free before interrupting. MORFO’s drones compute a fresh planting plan for every micro-plot of rainforest. Even the humble error message is learning to speak plain language and offer a way out.

None of the underlying ideas is new. Ted Nelson sketched humane, media-rich computing in 1974. Christopher Wickens formulated Multiple Resource Theory in the 1980s. Medieval scribes anchored commentary to the exact passage it explained 1,000 years ago. The vision was never the bottleneck; the cost of execution was. AI has collapsed that cost. So half-century-old ideas are finally shipping as products.

But cheap intelligence doesn’t hand out its winnings evenly. Firms spending $34 per employee per month on AI grew headcount by 10% while the $3 dabblers got nothing, and at the AI Film Festival, abundant production capacity mostly yielded another crop of pretentious art films. Production got cheap; taste stayed scarce. The rewards go to whoever does the reps.

Usability has always meant bending the machine to fit the human. For decades, that bending was expensive, so users did the contorting instead. AI makes it cheap, from a Thai senior’s spoken prompt to a seed capsule tuned for one patch of the Amazon. The keyboard is already planning its retirement party. Don’t let it save you a seat.

AI is inverting our decades-long problem with users having to adapt to the machine. Now AI adapts to us. (GPT Image 2)

A Final Thought

About the Author

Jakob Nielsen, Ph.D., is a usability pioneer with 43 years experience in UX and the Founder of UX Tigers. He founded the discount usability movement for fast and cheap iterative design, including heuristic evaluation and the 10 usability heuristics. He formulated the eponymous Jakob’s Law of the Internet User Experience. Named “the king of usability” by Internet Magazine, “the guru of Web page usability” by The New York Times, and “the next best thing to a true time machine” by USA Today.

Previously, Dr. Nielsen was a Sun Microsystems Distinguished Engineer and a Member of Research Staff at Bell Communications Research, the branch of Bell Labs owned by the Regional Bell Operating Companies. He is the author of 8 books, including the best-selling Designing Web Usability: The Practice of Simplicity (published in 22 languages), the foundational Usability Engineering (31,090 citations in Google Scholar), and the pioneering Hypertext and Hypermedia (published two years before the Web launched).

Dr. Nielsen holds 79 United States patents, mainly on making the Internet easier to use. He received the Lifetime Achievement Award for Human–Computer Interaction Practice from ACM SIGCHI and was named a “Titan of Human Factors” by the Human Factors and Ergonomics Society.

· Subscribe to Jakob’s newsletter to get the full text of new articles emailed to you as soon as they are published.

· Follow Jakob on LinkedIn.

· Read: article about Jakob Nielsen’s career in UX

· Watch: Jakob Nielsen’s first 41 years in UX (8 min. video)

Summary: How AI “skills” are reused and other usability issues with skills | User research job listings for junior staff dry up, and senior staff need AI experience to be hired | Data comics generated with AI increase student learning | Quick view as a shortcut for seeing product info | The AI economy has $175 billion in revenue | AI use spreads from peers | Automatically creating advertisements based on a website

UX Roundup for July 17, 2026 (Meta Muse Image)

AI “Skills” Need Usability Engineering

“Skills,” the SKILL.md packages that extend AI agents with reusable expertise, have become a genuine unit of software reuse: the first large-scale study counted 41,662 of them in the wild. But adoption is copy-and-forget: 53% of reused skills never receive a single update, and the rules that govern how agents treat users go almost untouched. Skills are a new user-interface layer that deserves usability research, and I propose an agenda.

An AI “skill” is like a sourdough starter for the AI: it tells it how to get going. (GPT Image 2)

A skill is a sourdough starter for an AI agent: you copy it from somebody who baked before you, feed it your own project’s particulars, and keep it alive with regular care. New research shows that most people skip the care part. They grab the starter, shove it in the fridge, and keep baking with it as it dies. Bad bread follows.

My recurring narrator characters, Alice and Zimo, explain AI skills and the new study on their reuse. (GPT Image 2)

Skills matter because they industrialize reuse. One expert packages hard-won procedural knowledge (how to run a security review, build a slide deck, or write in a house style), and thousands of users inherit that competence without doing any prompt engineering. When I called AI the first new UI paradigm in 60 years, the shift was from commands to intent-based outcome specification. Skills are how good intent specifications get packaged, shared, and reused, and a well-tended skill library increasingly separates casual AI use from advanced AI use. The format was popularized by Anthropic’s Claude and now has an open specification, with registries such as skills.sh hosting tens of thousands.

So what happens to skills once they leave the registry? Haoyu Gao and 5 colleagues from the University of Melbourne, Singapore Management University, and Heidelberg University just published the first large-scale empirical study of skills as engineered artifacts rather than mere agent capabilities. They mined 41,662 skills: 18,463 from the skills.sh registry and 23,199 personal-use skills across 5,876 GitHub repositories, then recovered 3,709 registry-to-local reuse links, hand-coded the content of 180 skills, and classified 444 modification diffs. A serious dataset for an artifact type that barely existed a year ago.

Adoption = Copy Once, Sync Never

The reuse numbers are stark. A whopping 70.3% of linked skill pairs are near-verbatim clones of the registry original. After adoption, 53% of reused skills never receive a single update. And frozen doesn’t mean fine: 40.2% of those untouched copies missed fixes their upstream originals later shipped. Even when adopters do edit, 62.3% diverge from upstream rather than pulling in its changes.

Thus, the skill ecosystem behaves like a package ecosystem without a package manager: no version pins, no update notifications, no dependency audits.

The stakes exceed ordinary documentation, and the authors explain why: a human reading a stale README can spot the discrepancy and route around it, but an agent executes a stale SKILL.md with full confidence. Call it skill rot: guidance that quietly decays while the machine keeps acting on it. Nobody proofreads at runtime.

The Interaction Contract Nobody Renegotiates

The content findings are where UX professionals should lean in. Coding 180 skills, the researchers identified 6 recurring content themes, and one is pure interaction design: 63% of skills script how the agent deals with its human, for example by gating consequential actions, such as merging pull requests, behind explicit user consent.

Now cross-reference that with what adopters and maintainers edit:

Even though user interaction is one of the main elements of AI skills, it gets almost no updates from skill adopters. (GPT Image 2)

Translation: whoever authors the first version of a popular skill is doing interaction design for thousands of downstream deployments he or she will never see. The consent gates, the escalation rules, the recovery behavior: adopters inherit them verbatim and never look back. The researchers call this stable core the skill’s behavioral contract, and it travels untouched.

One more red flag: maintenance is additive. In locally evolved skills, additions outnumber removals by 6.1 to 1. Skills grow; they’re rarely pruned. (In checking one of my own skills, I found 18 internal contradictions that had accreted across versions. Pruning is work. Skipping it is worse.)

6 UX Takeaways

1. Design the interaction contract first. Consent gates, escalation rules, and failure messages are the least-edited content in the dataset, so whatever you write at creation is what every downstream user will live with. Spend your best thinking there.

2. Write the description as microcontent. The YAML description is the skill’s information scent: it alone determines whether the agent invokes the skill. Activation metadata is the single most-edited element, which tells me the defaults are failing. Enumerate concrete trigger scenarios and explicit out-of-scope cases.

3. Treat adopted skills as dependencies, not downloads. Record the upstream source and diff against it on a schedule, because 40% of frozen copies are already missing upstream fixes. A quarterly review beats silent rot.

4. Prune on purpose. With additions outrunning removals 6.1 to 1, your skill will bloat into self-contradiction unless you schedule deletion passes. Every stale line costs tokens and risks steering the agent wrong.

5. Customize the bindings and leave the philosophy alone. The legitimate local edits are file paths, tool substitutions, and environment setup. Keep the core procedure intact so future comparisons against upstream stay readable.

6. Declare the optional metadata. Fields such as license, compatibility, and allowed-tools appear in only 3–16% of skills. The allowed-tools field in particular is a trust affordance for the person deciding whether to let your skill loose on his or her codebase.

A Research Agenda for Skill Usability

Gao and colleagues mined artifacts, not people. But repository mining can’t tell us what users experience, and as far as I know, nobody has watched a real user author, adopt, debug, or maintain an AI skill. That’s a gobsmacking gap for a mechanism this central to AI productivity. My agenda:

1. Discovery and selection. With tens of thousands of skills on offer, how does a user pick one? Do install counts mislead the way download counts misled in app stores? (Social proof doesn’t prove quality, only popularity.) Registry search deserves classic information-foraging research.

2. Pre-adoption vetting. Security audits cited by Gao’s team have already found exploitable vulnerabilities and credential leakage in community-authored skills. Can a non-expert assess a skill before installing it? My best guess (a guess until somebody runs the study) is that most users install skills the way they accept license agreements: unread. Test preview formats that let a person vet a skill in under a minute.

3. Activation debugging. Skills fire implicitly, and the heavy churn in activation metadata suggests users tune triggers by trial and error. We need tracing UIs that show why a skill did or didn’t invoke, plus studies of how people calibrate.

4. Authoring usability. Run think-aloud studies of first-time skill authors. What do they get wrong? Do the prefilled templates the researchers propose help? And what’s the optimal length? Registry skills run a median of 1,678 tokens; whether longer bodies help or hurt agent compliance is an open empirical question.

5. The cost of skill rot. Field-measure how often stale skills cause agent failures, and whether users can even attribute the failure to the skill rather than to the model. Then design and test notifications that make upstream drift visible.

6. Prose vs. scripts. Skills mix natural-language instructions (flexible but nondeterministic) with bundled scripts (rigid but testable). When should each carry the load? A dissertation awaits the Ph.D. student who maps this tradeoff across task types.

Skills Are an AI User Interface

Skills are how AI expertise compounds: one person’s mastery, everybody’s productivity. That makes them a user interface twice over: an authoring interface where humans encode intent, and a behavioral layer that scripts how agents treat the people they serve. Both halves are currently designed on instinct and frozen at adoption.

So feed your starter. Diff your adopted skills against upstream, prune the accreted sludge, and rewrite that activation description until the agent triggers exactly when it should. And researchers: the artifact mining is done, thanks to Gao and colleagues. Now let’s watch some actual users.

Junior User Research Jobs Getting Scarce; AI Experience Pays a 15% Premium

In mid-2026, the median salary for user researchers with AI skills was 15% higher than for UXR staff without AI skills. But to a first approximation, these jobs are reserved for senior staff. The tasks that juniors used to do are now handled by AI at the cost of a few tokens. (Meta Muse Image)

The new 3 R’s of UXR: For a Raise, Research Robots. Brian Utesch, Ph.D. (Head of UX Research at Cisco IT and co-creator of the UMUX-LITE questionnaire) analyzed 1,593 job postings for UX researcher positions collected in June–July 2026. AI now appears in 35% of postings, up from 10% in 2024 and 16% in 2025 in comparable data from Drill Bit Labs. Among the 728 postings that disclose pay, jobs mentioning AI offer a median salary of $178k, against $155k for jobs that don’t: a 15% premium, worth about $23k per year.

The share of user research jobs requiring AI skills more than tripled in only 2 years. I can’t imagine it won’t reach 100% by 2028. (Meta Muse Image)

What does “AI” mean in these postings? Having the skills needed to build AI products was requested 81% more often than having the skills to use AI tools within the research workflow. (Honestly, knowing how to use AI to do your job better should be table stakes these days, so many hiring companies probably don’t bother listing this.) Thus, one project shaping an AI feature beats a stack of prompt-engineering certificates on your resume.

If you want a career in the future, your overwhelming priority is to ship a product that uses AI. Building beats anything in the new world where any specific skill can be learned quickly through AI tutoring, if the AI isn’t doing that work itself in the first place. (Meta Muse Image)

The second finding is the seniority squeeze: 2/3 of postings target senior levels or above, only 10% welcome early-career researchers, and internships account for a measly 5%, while the median posting demands 5 years of experience. Newcomers must enter sideways: contract gigs, internships, or adjacent analyst roles. The front door is nearly shut.

Two more findings deserve attention:

• Degrees matter less than feared. 56% of job listings still require a degree, despite universities’ growing irrelevance to an agency-driven builder workplace. Even though companies sufficiently enlightened to hire for talent rather than credentials remain a (growing) minority at 44%, most of the degree requirements were simply for a bachelor’s. Only 14% ask for a Ph.D. Spend resume space on outcomes, not credentials. (Slightly deflating news for those of us who spent years getting a doctorate.)

• The classics anchor the craft. Usability testing appears in 67% of postings, with interviews and surveys at 50% each. Fancy methods come and go; watching users pays the mortgage.

The usual caveats apply: job ads tell us what employers want, which can differ from whom they hire, posted ranges omit equity, and the 2024–2025 trend splices in a separate sample (Drill Bit Labs coded 2,983 postings). But every mid-2026 figure was counted from real postings instead of estimated, so the direction is solid. Lead your resume with AI product research, name your methods exactly as employers do, and apply for the most senior title you can get away with, because those are most of the remaining jobs.

Build the skills and proven ability to ship AI products that will get you a job. Don’t assume that a shiny new diploma will get you an entry-level job. (GPT Image 2)

AI-Made Data Comics More Than Double Students’ Understanding of Data

In a controlled experiment with 60 university students, data comics drawn with generative AI beat conventional charts on every question type: median accuracy hit 75% vs. 33%. Comics helped most on hard comprehension tasks, but they lifted weak and strong readers by the same amount, so they don’t replace visualization literacy.

A chart hands readers a map. A data comic walks them through the territory with a guide who points out the sights. New research finally puts numbers on the difference: Zirui Shan and colleagues at Monash University, RMIT, and Hong Kong Polytechnic University compared the two formats in a within-subjects experiment with 60 university students, published on arXiv.

The team took 4 conventional climate-and-energy visualizations (stacked area charts and pie sequences) and rebuilt each as a data comic conveying the same insights. Panels were generated with DALL-E 3, prompted through ChatGPT and assembled in Canva, following Benjamin Bach’s design patterns for data comics, the closest thing this young genre has to a rulebook. Each student saw half the materials as charts and half as comics, counterbalanced, and answered 4 multiple-choice questions per display: half information retrieval (read off a value), half comprehension (derive an insight or spot the false statement among 4 options). Scores were corrected for guessing, a precaution too many studies skip.

In the spirit of the study, I’ll use my own comic strip to explain it. I made this Alice and Zimo comic with GPT Image 2. This is a much better image model than the old DALL-E 3 used by the researchers, so I’d expect even better outcomes in future projects using GPT Image 2 or Meta’s new Muse Image, which is almost as good.

The Harder the Question, the Bigger the Comics Advantage

Comics won across the board. Median accuracy reached 75% with comics vs. 33% with conventional charts (p < 0.001, with a large effect size of r = 0.66). And the gap widened exactly where thinking gets expensive. Retrieval questions improved by 16 percentage points on average, a moderate effect. Comprehension questions improved by an eye-popping 42 points: the median student facing a conventional chart scored a corrected zero on them. Zero! Questions that required integrating multiple insights showed the starkest split, with a median score of 100% for comics vs. 33% for charts.

Call it the panel premium: the accuracy bonus readers collect when insights arrive pre-analyzed, one panel at a time, with trends annotated and comparisons spelled out in speech balloons. The comic’s author has already done the analytical heavy lifting, so the reader consumes conclusions instead of computing them.

That last sentence is also the fine print. Several comprehension answers were printed right in the comics (the near-doubling of wind power sits on an arrow in plain text), so part of the measured gain is reading, not reasoning. Hongbo Shao’s earlier experiment showed that annotated charts alone deliver much of this benefit, and Zezhong Wang found in 2019 that comics beat infographics on enjoyment and recall. Add that the new study used only 4 visualization pairs, all on climate topics, and a sample of 60 participants, including 22 doctoral students. Hardly a cross-section of humanity. But the within-subjects design, counterbalancing, and guessing correction are solid, and effects this large survive quibbles. As the first controlled test of GenAI-assisted data comics against conventional visualizations, the study clears the bar.

A Rising Tide That Doesn’t Close the Gap

Could comics be the great equalizer that lets chart-blind students catch up with their data-fluent classmates? No. Visualization literacy, measured with the 12-question Mini-VLAT instrument, strongly predicted accuracy in both conditions. Comics added roughly 28 percentage points for everybody, novice and expert alike; the interaction between literacy and format was nowhere near significance (p = 0.75).

Thus data comics raise the floor and the ceiling by the same amount. That finding deserves attention because it breaks a pattern: in my writing on AI and skill gaps, I’ve documented how AI tools compress the spread between weak and strong performers. Data comics don’t. They’re a ramp, not an elevator; everyone climbs, but nobody changes floors. So deploy comics for communication, and keep teaching people to read charts, because the literate reader extracts more from whatever format he or she is given, comics included.

Students Cheered the Comics, Then Booed the Robot

Perceptions matched performance. Fully 90% of participants (54 of 60) called comics more accessible and efficient than charts, and 44 praised their engagement value. (20 also claimed comics were easier to remember, but the study never tested memory, so file that under self-report.) Still, 60% flagged drawbacks: busy layouts that bury the key number, and, more astutely, the author-guided narrative. One participant objected that comics limit “the audience’s ability to make their own opinions or extract their own insights.” Exactly right. The pre-chewed insight is at once the format’s superpower and its bias risk, because whoever sequences the panels decides what you conclude.

The twist came at the end, when the researchers revealed that all the comics were AI-generated. Suddenly 75% expressed misinformation concerns, 2/3 worried about bias, and 37 of 60 fretted over copyright and ownership. Note the irony: these same students had just performed twice as well with the AI-made material. It’s sad that AI stigma remains in effect, even among university students who have just benefited from AI-assisted learning. Reducing AI stigma should be a top priority for AI labs to spend their billions on.

Conclusion: Let AI Draw, but Keep Humans Directing

Rodolphe Töpffer, a Geneva schoolmaster, published the first modern comic strips in 1833, partly to amuse his students. Two centuries later, the format is returning to the classroom with an AI inker, and the evidence says it works. My advice:

• Use data comics for novice and mixed audiences. Student dashboards, executive summaries, and public reports are prime territory. Expert analysts still need raw charts for open-ended exploration, since comics show only what the author chose to show.

• Split the labor the way the researchers did. Humans extract the insights and sequence the story, AI draws the pictures, and humans verify every number in every speech balloon before publication. One hallucinated digit torches your credibility.

• Disclose the AI involvement, and expect skepticism. Readers penalize trust, not comprehension. Earn the trust back with visible human oversight.

• Keep funding visualization literacy. Comics raise everyone equally, but they don’t rescue the bottom of the class.

I practice what I preach: my own articles are illustrated with AI-generated comics, because a guided tour beats a map for first-time visitors. Just make sure the guide isn’t inventing the sights.

Quick View: Handy for Triage, Hopeless as a Product Page Substitute

A “quick view” overlays an item’s essential details on top of a list so users can inspect without navigating away. It shines for visual triage and misfires when it impersonates the full detail page: in Baymard Institute’s testing, shoppers mistook the overlay for the real product page and never saw the information that page contained. Fix the list item first; add a quick view only for what remains.

Quick view, dramatized: the rest of the catalog stays under wraps while one candidate steps into the light. In production designs, the “View Details” link carries the load. (GPT Image 2)

Definition: A quick view is an overlay or panel, opened from an item in a list or grid, that presents a summary of that item’s details (a larger image, price, key attributes, and a primary action) without leaving the list for a new page.

The user’s investment stays tiny: peek, judge, dismiss, move on. The pattern lives or dies on that tininess. The moment a quick view demands the attention of a full page while delivering less than one, it has lost its reason to exist.

From the Mac’s Spacebar to Every Store’s Product Grid

Apple shipped the pattern’s most elegant incarnation in Mac OS X Leopard (2007): Quick Look, where pressing the spacebar instantly previews a file at full size, and pressing it again dismisses the preview. Zero commitment, zero mode. E-commerce sites adopted “Quick View” buttons on product cards in the years that followed, promising relief from the tedious bounce between the product list and the product pages. (Jared Spool named that bounce “pogo-sticking” long ago.) The name itself needs no etymology lecture: it’s a view, and it’s quick. Would that all pattern names were this honest.

Why Quick View Works: Inspection Without Losing Your Place

What does each trip to a full product page cost the user? three things: a page load, the cognitive reset of parsing a new layout, and the relocation work of finding his or her position in the list afterward. Multiply by 15 candidate products, and a browsing session becomes mostly overhead. A quick view eliminates all three costs for the products that only needed a glance.

The benefit concentrates in visually driven products: apparel, furniture, decor, art. Baymard’s testing found that for such goods, the enlarged image often settles the matter by itself; a user judging a dress mainly needs to see the dress bigger. Desktop file managers prove the same point daily: spacebar, glance, arrow, glance, and 30 files are triaged in a minute. Quick views also preserve the list’s sort order and scroll position, which users have often invested real effort in setting up.

How Quick View Fails: The Quick-View Cul-de-Sac

Baymard Institute has tested this pattern with real shoppers for over a decade, and the findings are unflattering. At the pattern’s 2015 peak, its benchmark found 48% of top US e-commerce sites offering quick views; the shine has since worn off, yet its current benchmark shows 21% of sites still shipping the feature for spec-driven catalogs, where it helps least. The signature observed failure: shoppers mistook the overlay for the actual product page. Ponder what that error costs. The shopper “reads the product page,” finds no size chart, no shipping terms, no reviews, concludes the site is hiding basics, and leaves. The real page had everything. He or she never saw it.

This design flaw is the quick-view cul-de-sac: an overlay that lacks the information needed to decide, while obscuring the road to the page that has it. Two further failure modes compound the damage. Hover-triggered overlays open by accident as the mouse crosses the grid, ambushing users en route to something else. And for spec-driven products (electronics, appliances, tools), Baymard concluded the pattern rarely helps at all: buyers need the full specification table anyway, so the institute’s advice is to skip the quick view and invest in a stronger product list. (Baymard sells research subscriptions, so season to taste, but the finding rests on moderated observation of real shoppers, and it matches what I’ve watched users do since the 1990s: treat whatever fills the screen as what the site has to offer.)

The cures are direct: make the link to the full page the most prominent element in the overlay, include the 3–5 attributes that genuinely decide purchases in your category, and open only on a deliberate click, never on a hover.

8 Design Guidelines for Quick View

1. Fix the product list first. If list items already show the deciding attributes, a quick view may be redundant; Baymard found that strong lists eliminate the need for most users.

2. Open on click or tap only. Hover-triggered overlays ambush users who were aiming at something else, and they don’t exist at all on touch screens.

3. Make the full-page link unmissable. A large “View Full Details” button within the quick-view card, not a text whisper, is the single best defense against the cul-de-sac.

4. Include the decisive attributes. Price, availability, ratings, and the 2–3 category-specific facts (fabric, dimensions, compatibility) users need for a keep-or-discard call.

5. Keep it visually distinct from the page. The dimmed list should remain visible behind the overlay, with a prominent close control, so nobody mistakes the peek for the page.

6. Return users to their exact spot. Closing the overlay must restore the scroll position and any selections; place-keeping is the entire point of the pattern.

7. Rethink it on mobile. A small screen makes the overlay nearly page-sized anyway, so most sites should link straight to the product page there.

8. Drive both views from one source. The quick view and the product page must never disagree on price or stock; a mismatch is a lawsuit-adjacent bug, and shoppers punish it with abandonment.

The AI Economy Is Real: $175 Billion in Revenue, Growing 3x Faster Than the Internet Did

Exponential View’s new State of the AI Economy report measures $110 billion in trailing 12-month GenAI revenue, now running at a $175 billion annualized pace and scaling 3x faster than any prior IT wave. The demand side of my AI analysis is confirmed, several of my 2026 predictions are ahead of schedule, and the industry’s remaining bottleneck is converting tokens into completed tasks.

Azeem Azhar and his Exponential View team have published The State of the AI Economy (June 25, 2026), the first credible attempt to measure AI demand rather than AI supply. Everybody can read Nvidia’s earnings; nobody could say what customers actually pay for machine cognition, because the biggest labs are private, and public companies bury AI revenue inside segment totals. That obscure demand underpins $22.7 trillion of market value. The team built a bottom-up model of 1,000+ firms, confidence-scored every source, and (crucially) deduplicated: $100 of app spend that passes $60 to a model provider, which spends $30 on hosting, counts as $100, not $190. My verdict: that discipline alone makes it the reference source on AI demand.

Demand Is Real: $1 Billion Every 2 Days

In 2023, the AI industry needed 180 days to add $1 billion in cumulative revenue. It now needs less than 2 days: a 90x acceleration in 3 years. Growth has held at 35% quarter-over-quarter (3.2x annually) across the two adoption phases the report labels the Chatbot Subscription Era and the Agentic Coding Era.

In How Big Is AI? Four Analogies, I argued the Internet is a useful starting analogy but a bad stopping point, and that AI’s impact will exceed 10x the Internet’s. The report supplies the velocity evidence: time-aligned to year zero and adjusted for inflation, GenAI revenue is scaling 3x faster than the Internet (1995), mobile apps (2007), or cloud (2010) ever did.

(A reconciliation note: Gartner’s $2.5 trillion figure for 2026 AI spending, which I cited, counts the shovels: data centers, chips, infrastructure. Exponential View’s $175 billion counts what customers pay for apps, models, and hosting, ex-China and deduplicated. Both are right; they measure different layers of the same machine.)

That machine is the one from my analogies article, where I called data centers cognitive power plants; the report likewise frames the stack as converting capital and energy into cognition. The plants are running hot: hyperscalers hold a $2.0 trillion contract backlog, and US electricity generation is growing again (+9 TWh/month per year) after 16 flat years.

Big Is Still Small: 0.42% of GDP

Now the part the boosters will skip. AI revenue equals 0.42% of US GDP, versus 9.4% for the IT sector, and corporate profits are 32x larger than all GenAI revenue combined. Even Uber, a top-10% AI spender per employee (capped at $1,500 per engineer per month), only spends roughly $90 million a year on AI: 0.2% of its revenue. A rounding error in the P&L.

And 7 in 10 corporate AI claims on earnings calls concern cost savings or efficiency, not revenue. Thus most companies are still sprinkling AI on industrial-era processes instead of redesigning workflows to be AI-first, exactly the trap I warned about. The prize for doing better shows up in the report’s Ramp data (n = 70,000 US businesses): the top quartile of AI spenders grew revenue 92 percentage points faster than firms with no AI spend since late 2022.

The report also quantifies what I could only assert: measured revenue understates AI’s value. Stanford Digital Economy Lab surveys peg US consumer welfare from AI at $14 billion per month against $11 billion of revenue, roughly a 30% consumer surplus on top of the bill. Electric lighting registered approximately $0 of direct GDP impact too, per Nordhaus’s 1996 analysis. History rhymes.

The $2 Trillion Buildout Meets Its Depreciation Bill

My Prediction 7 for 2026 was a persistent compute crisis; at my mid-year reality check, I scored it 88%, my highest mark. The report supplies receipts across my scorecard :

CapEx hits $2 trillion cumulative through 2026: $848 billion this year alone, $535 billion above the pre-AI trend. The sober math: the 2026 depreciation charge approaches $111 billion. Q4 2025 was the first quarter in which AI revenues exceeded quarterly CapEx depreciation, and headroom now sits at 19% for infrastructure players (32% across all GenAI revenue). In plain English: depreciation eats roughly 81 cents of every hyperscaler AI dollar before anybody pays for electricity, staff, or marketing. Coverage is real but thin. The report’s cheekiest finding: 8-year-old T4 GPUs still earn 42% gross rental yields, so betting on longer chip lives stretches headroom to 36%. The buildout is paying back, for now, and those last two words carry the whole investment case.

Tokens: Jevons Paradox, Finally Measured

In January, I invoked the Jevons Paradox: efficiency increases total consumption. The report measures it. Blended token prices collapsed from $17 to $2 per million (an 88% decline) while volumes grew 14x year-over-year to a staggering 30 quadrillion tokens per month. (Token counts include China, unlike the revenue figures. Noted.) Across providers, demand elasticity runs about 1.2–1.8: every 10% price cut yields 12–18% more tokens, so total spend still rises. The team flags that this is a time-series estimate that may overstate pure price elasticity. Methodological candor: rare and appreciated.

When something is cheaper, customers buy more. But how much more? That’s determined by price elasticity: if demand is highly elastic, it can skyrocket by much more than the price drop, meaning that seller revenues grow even though the seller gets less money for each unit sold. This is the case with AI. The world wants much more cheap cognition. (GPT Image 2)

Agents are the accelerant, as my Prediction 8 anticipated: an agentic coding task consumes 4.17 million tokens, roughly 1,200x a chat task. So what is a token actually worth? The report’s sharpest section admits nobody knows. Electricity found its unit of value in kilowatt-hours (Edison billed his first customers per lamp; metering came later), the web found clicks, and mobile found active users. AI bills in tokens, but a token measures cognition produced rather than problems solved. The report proposes quality-adjusted output tokens as the closest usable unit. I’ll push one step further, back to my January claim that the enterprise metric shifts from tokens generated to tasks completed: the true economic unit of AI is the completed task, and the token-to-task exchange rate is set by usability. Every confusing agent interface, unverifiable output, and forced re-prompt debases the currency.

No Moat, Confirmed: Intelligence Got Cheap, Access Got Expensive

The report exposes the commoditization mechanism behind my no-moat prediction: frontier labs earn a time-limited premium, and last year’s frontier diffuses into open weights within roughly a year. Among OpenRouter’s self-selecting model routers, Google, OpenAI, and Anthropic fell from 72% to 33% of token share in a year. And what are the labs doing about it? Exactly what my mid-year analysis said they would: converting temporary intelligence leads into durable access positions via vertical apps (legal AI from both OpenAI and Anthropic) and their own infrastructure (Stargate; Anthropic’s $50 billion data center program). Value is creeping up the stack: apps plus foundation models grew from 13% to 18% of deduplicated revenue in one year. Hosting still takes 82%, but UX lives where the other 18% is growing.

The report ends by asking whether falling prices can move enough token volume to repay the CapEx. My answer: only if the token-to-task exchange rate improves, and that rate is set by design. Here’s what to do about it.

To Plan Your Company’s AI Strategy:

1. Budget for elasticity, not a line item. Unit prices fell 88% while total spend rose. Manage tokens like cloud spend, with quotas, per-project attribution, and performance-per-dollar targets.

2. Copy the winners’ intensity. Uber’s top-10% spend is 0.2% of revenue: basically free. Against a 92-percentage-point growth gap between heavy adopters and abstainers, underspending is the expensive option. Aim past the 70% efficiency projects toward revenue-side workflow redesign.

3. Architect for model churn. Frontier premiums decay within a year as open weights catch up. Keep switching costs near zero and never sign long exclusives with today’s leader.

To Lead a UX Team:

1. Own the token-to-task exchange rate. Instrument task completion per inference dollar and report UX outcomes in the same units the CFO sees on the AI bill. UX = Profits, now with a meter attached.

2. Staff for verification, not generation. Agentic work burns 1,200x the tokens and produces output humans must check. Build capability in audit interfaces, risk-ranked review, and agent legibility before review fatigue caps adoption.

3. Treat compute as a design material. Rate limits, tiering, model routing, and honest disclosure of silent downgrades are core interaction design now, as unavoidable as screen size was in the mobile era.

To Plan Your Own UX Career:

1. Move to where the tokens flow. The Agentic Coding Era is the growth engine, and the app layer, where UX differentiates, is gaining share. Screen-polishing shrinks; agent and workflow design grows.

2. Learn to read this report. A designer who argues in margin per task, elasticity, and depreciation headroom gets invited to strategy meetings. One weekend of study buys years of credibility.

3. Pay for the frontier. The two-tier AI world rewards premium-tool mastery, and skills compound quarterly. Expense the subscription or buy it yourself, but don’t build your future on the free tier.

Edison’s customers paid per lamp because nobody had invented the meter. AI has a meter, and it’s spinning 30 quadrillion times a month. But customers don’t want electrons; they want light. Find a way to meter the AI light.

AI Use Spreads from Colleague to Colleague, Not from Promoting It

For as long as I’ve been in UX, one lesson has remained constant: users don’t read the manual. Social learning is by far the number one way of increasing users’ computer skills. (GPT Image 2)

Telemetry from Microsoft engineers shows that the strongest predictor of trying an AI coding agent is whether coworkers already use it: heavy peer exposure raised the odds of first use by 216%. We learned spreadsheets from the next desk over in 1986, and we’re learning AI agents the same way in 2026.

Emerson Murphy-Hill, Jenna Butler, and Alexandra Savelieva at Microsoft tracked tens of thousands of engineers through the company’s early-2026 rollout of two agentic command-line tools, Claude Code and GitHub Copilot CLI. They paired usage telemetry with HR records instead of relying on surveys, so we’re watching what engineers did, not what they say they did.

The adoption results form a clean hierarchy. When more than a quarter of an engineer’s skip-level peers (colleagues who report to the same manager’s manager) already used the tool, the odds of trying it were a whopping 216% higher than for an engineer with no exposed peers. A manager who used the tool raised the odds by 82%, and frequent code-review partners raised them by 54%. Meanwhile, tenure predicted nearly nothing, and career stage produced only a gentle gradient. What engineers do predicts adoption; who they are barely matters.

Observing colleagues achieve impressive results with AI motivates laggards to try it for themselves. (GPT Image 2)

And the spread is worth having: adopters merged 24% more pull requests, a lift that held across the full 4-month window and rose to +50% in weeks with 5+ days of tool use. (Two caveats the authors admit: the analysis can’t fully separate peer influence from homophily, since similar engineers cluster on similar teams, and Microsoft owns GitHub, maker of Copilot CLI. Still, the adoption pattern survived their sensitivity checks.)

The AI users completed 24% more tasks in this study. Note that this often doesn’t equate to creating 24% more value for the company, but the AI productivity lift does keep being confirmed. (GPT Image 2)

The Manual Nobody Read

Readers of a certain age will recall how they actually learned WordPerfect or Lotus 1-2-3. The 400-page manual stayed in the shrink wrap; the teacher was Carol, two desks over, who knew the keyboard shortcuts. RTFM (“read the fine manual,” in the polite expansion) was an insult precisely because nobody did. This was the cubicle curriculum: the informal syllabus taught desk to desk, absent from every training budget, yet the way computer skills have always spread.

Skills spread from desk to desk in the workplace. (GPT Image 2)

Murphy-Hill documented the mechanism a decade ago: peers are an effective way for software users to discover new tools, but such tool talk happens only once every few months. The bottleneck was frequency, not effectiveness. AI agents loosen that bottleneck because their output is conspicuous. A colleague who ships a gnarly refactoring in an afternoon gets asked how.

Make Use Visible

This study is behavioral confirmation of my playbook for building an AI-positive work culture, where National Bureau of Economic Research survey data showed 47% AI adoption when employers encouraged it versus 10% when they stayed silent. Now hard telemetry says the same: a visibly active manager nearly doubles the odds that a team member tries the tool. Culture beats curriculum, and the log files agree.

Culture beats curriculum, and AI rollouts are no exception. (GPT Image 2)

• Make usage observable. Demos, shared prompts, and a standing 5-minute “what I tried” slot in team meetings. Skip-level exposure was the strongest signal, so broadcast wins beyond the immediate team.

• Managers go first. Encouragement without visible personal use reads as performative; +82% is the payoff for practicing what you preach.

• Buy tools and time, not curriculum. Formal training predicted nothing in the NBER data, while peer exposure predicted everything here.

Managers must explicitly endorse AI and showcase their own use to increase uptake. (GPT Image 2)

To encourage AI use, use it yourself, instead of sitting in the chair doing nothing. (GPT Image 2)

Conclusion: Rollouts Are Social Events

The manual didn’t teach the office of 1986, and the training deck won’t teach the office of 2026. New tools spread when people watch respected colleagues get real work done with them. Budget for visibility. The cubicle curriculum is already in session; your only decision is whether to give it a classroom.

To increase AI use, organize social learning events where colleagues show-and-tell how they use AI. (GPT Image 2)

Automatically Creating Advertisements with Gooseworks

A new AI service automatically creates social media promotions and advertisements, requiring almost no input other than your URL (from which it derives your brand proposition). You also pick your preferred styles from a set of existing ads that it will use as templates. The service is called Gooseworks Ads, and I have to compliment them on a memorable name.

Of course, I had to try this for UX Tigers, and here are some ads the Goose made for me in a few minutes of computer time and about a minute of my time:

(Gooseworks)

Pretty good promotions for UX Tigers. I can see small companies using this service and being happy with the results. Would Coca-Cola use them? No, these AI-generated ads aren’t up to the standards you get from paying millions of dollars to a high-end advertising agency. Yet. In two years, who knows.

Gooseworks didn’t get my logo quite right: that’s the downside of automatically downloading the low-resolution version from the upper right corner of my web pages instead of having access to higher-resolution assets. (There’s a feature to upload existing assets to a brand kit, but I wanted to see what I could get from pure AI.)

You get enough free credits to make about 10 ads, so go ahead and give this a try. You can change the aspect ratio to fit your needs. I just stuck with the default, since I don’t run any ads and thus won’t be using these creations beyond posting them here in the newsletter.

Gooseworks is currently mainly for smaller clients who can’t afford a high-end advertising agency. But I expect it to follow Clayton Christensen’s theory of disruptive innovation and gradually eat the markets of larger and larger ad agencies as it improves with more powerful AI language and image models over the next 2–3 years. (GPT Image 2)

Conclusion: Welcome to the Handoff Economy

In mid-2026, competence travels secondhand. A skill author scripts how agents will treat users he or she will never meet. A data comic pre-chews the analysis so students consume conclusions instead of computing them. Engineers adopt AI coding agents because a colleague two desks over shipped something impressive, not because anybody read the manual. Gooseworks turns a bare URL into finished advertisements. Even the humble quick view is a handoff: the shopper trusts an overlay to stand in for the full product page. Every item in this issue is about inheriting somebody else’s thinking, and every failure it reports (skill rot, the quick-view cul-de-sac, AI stigma) is a handoff that nobody verified.

The money says the arrangement works: GenAI revenue runs at a $175 billion annualized pace, scaling 3x faster than the Internet did, and user researchers who can build AI products collect a 15% salary premium. But the same numbers expose the constraint. Depreciation eats 81 cents of every hyperscaler AI dollar, the front door for junior researchers is nearly shut, and nobody has invented the meter that converts tokens into completed tasks. Call it the handoff economy: value is created upstream, consumed downstream, and lost in the middle whenever the interface fails.

That middle is UX territory. The state of affairs in one sentence: AI’s demand is proven, its supply is prodigious, and usability is the bottleneck that decides who profits. Intelligence got cheap. Verified handoffs didn’t. Closing that gap is the UX job of the decade, and unlike the junior listings, this one is wide open.