UX Prompt Design is not a new tool. It is the next version of a skill you already have – built from user research, design systems, accessibility standards, and brand knowledge. The question is whether you use it deliberately, or let someone else define it for you.

Key Takeaways

UX designers are better positioned for prompt design than most developers – because good prompting requires exactly what UX research trains: structuring intent, anticipating edge cases, communicating constraints precisely. The base prompt is the design brief. Research, heuristics, accessibility, and brand rules go in before the first output appears. The task is last. And the work doesn’t end there – testing, QA, and research continue. The gap to tech is smaller. The gap to the user is the same size it has always been.

A Moment That Shifted Something

There was a point, not long ago, where I stopped opening Figma first.

Not because I stopped caring about design. But because I was spending more time describing what I wanted than building it. The moment I learned to describe it precisely – to a model that could read the design system, understand the component constraints, and produce something that matched the pattern – the tool became secondary. The thinking behind it didn’t.

That thinking is UX. And it turns out it’s exactly what prompt design needs.
 

What Prompt Design Is

Prompt design is writing the instructions, constraints, and context that shape how an AI system produces output. In a product context, it’s the invisible layer between what users intend and what they experience.

It’s not a developer skill. It’s not about syntax.

A user journey is a structured description of intent, context, constraints, and expected outcomes. So is a good prompt. An information architecture defines what belongs together and what the system should prioritise. So does a good system prompt. A usability test reveals where a mental model breaks down and where language fails. Prompt iteration does the same – you run it, watch where it fails, refine.

The research skills UX designers have built are not adjacent to prompt design. They are the foundation of it.

How I Build a UX Prompt

I don’t start with the component. I start with the same questions I’d ask at the beginning of any UX project: Who is using this? In what context? What do they need to understand immediately?

Every prompt I write is built on five layers, set before any output is generated.

Nielsen Norman’s heuristics – baked in as constraints, not appended as a checklist. Visibility of system status, user control, error prevention, consistency. They define what the interaction is allowed to do.

Accessibility (WCAG 2.1 AA) – contrast ratios, keyboard navigation, focus states, touch targets, screen reader behaviour. If the output fails on accessibility, the prompt failed first.

Industry context and UX trends – a banking interface carries different expectations than a health app or a B2B dashboard. Each sector has patterns, regulatory constraints, and user mental models. I research before I write.

UX research – existing interviews, usability tests, session data – translated directly into specific constraints. “Users miss secondary actions here.” “At this step, trust matters more than speed.” That specificity is the difference between a generic screen and one aligned with how real users behave.

Brand behaviour – how the brand moves, what it says, and what it never does. Transition timing, easing, dos and don’ts, UX writing rules. Every brand has a signature. A prompt without those rules defaults to generic – and generic is off-brand by definition.

The Base in Practice

All five layers form the base prompt – the fixed ground every output inherits from. The task is always last.

Here is what that looks like for a consumer fintech product:

DESIGN SYSTEM
Use only components from the Meridian design system.
Token references: --color-primary (#1A3A6B), --spacing-base (8px grid).
Never invent new components. Flag missing patterns – don't improvise.

ACCESSIBILITY — WCAG 2.1 AA
Contrast: 4.5:1 text, 3:1 UI components. All elements keyboard navigable.
Focus states always visible. Touch targets minimum 44×44px.
Error states: icon + text always. Never colour alone.

USABILITY — NIELSEN NORMAN
Show system status always. Use real-world language – "transfer", not
"initiate a funds movement transaction". Every destructive action needs
confirmation. Validate inline. Design every state: empty, loading, error, success.

BRAND BEHAVIOUR
Motion: ease-out only, 150–250ms. Never bouncy. Never stacked animations.
DO: whitespace, one CTA per view, trust signals near financial actions.
DON'T: urgency language, animated numbers, unconfirmed destructive actions.

UX WRITING
Voice: trusted expert. Calm, clear, precise.
CTAs: verb-first, 1–3 words. "Send money" not "Proceed with transfer".
Errors: what happened + what to do.
→ "We couldn't process this. Check your details and try again."

RESEARCH
Users think in "accounts" – not "wallets". Abandon at >3 fields per screen.
Before payment: "Is this the right person?" "Can I undo this?"
78% mobile. Primary actions in thumb zone.

─────────────────────────────────
Everything above is fixed. Task comes after.

TASK
Design a payment confirmation screen. User has entered recipient and amount.
Show all relevant details. Primary CTA: confirm. Include edit path back.

The task is five lines. The base is fifty. That ratio is intentional – the more precisely the ground is set, the less correction the output needs.
<div style="font-family:inherit;max-width:100%;margin:48px 0;">
<style scoped>
/* ── wrapper ── */
.sim{--accent:#1A3A6B;--ok:#2d7a4f;--bg:#f7f7f7;--border:#e0e0e0;max-width:100%}
.sim-label{font-size:12px;font-weight:700;letter-spacing:.1em;text-transform:uppercase;color:#888;margin-bottom:10px}
.sim-title{font-size:18px;font-weight:800;color:#212121;margin-bottom:6px}
.sim-sub{font-size:14px;color:#666;margin-bottom:24px;line-height:1.5}

/* ── prompt box ── */
.sim-prompt{background:#111;border-radius:12px;padding:22px 24px;margin-bottom:16px;position:relative}
.sim-prompt pre{font-family:monospace;font-size:13px;line-height:1.8;color:#aaa;margin:0;white-space:pre-wrap;word-break:break-word}
.sim-prompt .hl{color:#fff;font-weight:700}
.sim-prompt .hl2{color:#7ec8f7}
.sim-prompt .hl3{color:#98e0a8}

/* ── run button ── */
.sim-btn{display:inline-flex;align-items:center;gap:8px;background:var(--accent);color:#fff;border:none;border-radius:8px;padding:12px 22px;font-size:14px;font-weight:700;cursor:pointer;transition:opacity .15s;margin-bottom:24px}
.sim-btn:hover{opacity:.85}
.sim-btn:disabled{background:#bbb;cursor:not-allowed}
.sim-btn2{background:#212121}

/* ── processing ── */
.sim-proc{display:none;align-items:center;gap:10px;padding:16px 20px;background:var(--bg);border-radius:10px;margin-bottom:20px;font-size:14px;color:#666}
.sim-proc.active{display:flex}
.dot{width:8px;height:8px;border-radius:50%;background:var(--accent);animation:pulse 1.2s ease-in-out infinite}
.dot:nth-child(2){animation-delay:.2s}
.dot:nth-child(3){animation-delay:.4s}
@keyframes pulse{0%,80%,100%{transform:scale(.6);opacity:.4}40%{transform:scale(1);opacity:1}}

/* ── output panel ── */
.sim-out{display:none;gap:32px;align-items:flex-start;flex-wrap:wrap;margin-bottom:28px}
.sim-out.active{display:flex}

/* ── phone mockup ── */
.phone-wrap{flex:0 0 auto}
.phone{width:220px;background:#111;border-radius:28px;padding:10px;box-shadow:0 12px 40px rgba(0,0,0,.18)}
.phone-bar{height:24px;background:#222;border-radius:10px 10px 0 0;margin-bottom:0;display:flex;align-items:center;justify-content:center}
.phone-bar-dot{width:50px;height:4px;background:#333;border-radius:2px}
.phone-screen{background:#fff;border-radius:6px;padding:20px 16px 24px;min-height:340px;display:flex;flex-direction:column;position:relative;overflow:hidden}

/* ── static screen content ── */
.sc-progress{display:flex;gap:6px;justify-content:center;margin-bottom:24px;margin-top:4px}
.sc-dot{width:8px;height:8px;border-radius:50%;background:#e0e0e0}
.sc-dot.active{background:var(--accent)}
.sc-icon{width:56px;height:56px;background:#eef2ff;border-radius:16px;margin:0 auto 16px;display:flex;align-items:center;justify-content:center;font-size:26px}
.sc-title{font-size:17px;font-weight:800;color:#111;text-align:center;margin-bottom:8px;line-height:1.3}
.sc-body{font-size:11px;color:#888;text-align:center;line-height:1.5;margin-bottom:20px;flex:1}
.sc-cta{background:var(--accent);color:#fff;border:none;border-radius:10px;padding:12px;font-size:13px;font-weight:700;text-align:center;cursor:default;margin-bottom:10px}
.sc-skip{font-size:11px;color:#aaa;text-align:center;cursor:default}

/* ── animated screen content ── */
.sc-title.anim{animation:fadeIn .4s ease-out .1s both}
.sc-cta.anim{animation:slideUp .3s ease-out .25s both}
.sc-dot.active.anim{animation:dotPulse 1.5s ease-in-out .4s infinite}
@keyframes fadeIn{from{opacity:0;transform:translateY(-6px)}to{opacity:1;transform:none}}
@keyframes slideUp{from{opacity:0;transform:translateY(16px)}to{opacity:1;transform:none}}
@keyframes dotPulse{0%,100%{transform:scale(1);opacity:1}50%{transform:scale(1.4);opacity:.7}}

/* ── annotation ── */
.annots{flex:1;min-width:180px;display:flex;flex-direction:column;gap:10px;padding-top:8px}
.annot{background:var(--bg);border-radius:8px;padding:12px 14px;border-left:3px solid var(--border)}
.annot.done{border-left-color:var(--ok)}
.annot-head{font-size:12px;font-weight:700;color:#212121;margin-bottom:3px}
.annot-body{font-size:12px;color:#666;line-height:1.5}
.annot-tag{display:inline-block;font-size:11px;font-weight:700;padding:1px 7px;border-radius:20px;background:#e8f5e9;color:var(--ok);margin-top:4px}

/* ── step divider ── */
.sim-divider{display:flex;align-items:center;gap:12px;margin:8px 0 24px;color:#bbb;font-size:12px;font-weight:700;letter-spacing:.08em;text-transform:uppercase}
.sim-divider::before,.sim-divider::after{content:"";flex:1;height:1px;background:#e0e0e0}

@media(max-width:520px){.sim-out{flex-direction:column}.phone{width:100%;max-width:220px}}
</style>

<div class="sim">
<div class="sim-label">Interactive Demo</div>
<div class="sim-title">Prompt → Processing → UI</div>
<div class="sim-sub">This is what the workflow looks like in practice — from a structured prompt to an animated interface.</div>

<!-- STEP 1: UI PROMPT -->
<div class="sim-label">Step 1 — The UI Prompt</div>
<div class="sim-prompt">
<pre><span class="hl">DESIGN SYSTEM</span>  Meridian · --color-primary (#1A3A6B) · 8px grid
<span class="hl">ACCESSIBILITY</span>  WCAG 2.1 AA · 44×44px touch targets · Focus visible

<span class="hl">BRAND</span>  Tone: calm, trusted · Motion: ease-out, 150–250ms
<span class="hl">UX WRITING</span>  Verb-first CTAs · Max. 2 lines body text

──────────────────────────────
<span class="hl2">TASK</span>
<span class="hl3">Onboarding screen, step 1 of 3. Meditation app.
Progress indicator, headline, short description, primary CTA.
Everything in thumb reach. No scrolling.</span></pre>
</div>
<button class="sim-btn" id="btn1" onclick="runStep1()">&#9654; Run prompt</button>

<!-- PROCESSING 1 -->
<div class="sim-proc" id="proc1">
  <span class="dot"></span><span class="dot"></span><span class="dot"></span>
  Generating UI concept…
</div>

<!-- OUTPUT 1 -->
<div class="sim-out" id="out1">
  <div class="phone-wrap">
    <div class="phone">
      <div class="phone-bar"><div class="phone-bar-dot"></div></div>
      <div class="phone-screen">
        <div class="sc-progress">
          <div class="sc-dot active"></div>
          <div class="sc-dot"></div>
          <div class="sc-dot"></div>
        </div>
        <div class="sc-icon">🌿</div>
        <div class="sc-title">Find your calm.</div>
        <div class="sc-body">Three minutes a day is all it takes. No prior experience needed.</div>
        <div class="sc-cta">Get Started</div>
        <div class="sc-skip">Skip for now</div>
      </div>
    </div>
  </div>
  <div class="annots">
    <div class="annot done"><div class="annot-head">Progress indicator</div><div class="annot-body">3 dots, step 1 active — matches the prompt parameter exactly.</div><span class="annot-tag">✓ Defined in prompt</span></div>
    <div class="annot done"><div class="annot-head">Primary CTA</div><div class="annot-body">Verb-first ("Get Started"), full width, within thumb reach.</div><span class="annot-tag">✓ Brand-compliant</span></div>
    <div class="annot done"><div class="annot-head">No scrolling</div><div class="annot-body">All elements fit one viewport — as specified.</div><span class="annot-tag">✓ WCAG-compliant</span></div>
    <div class="annot"><div class="annot-head">Next step</div><div class="annot-body">Add interactions and transitions with a second prompt.</div></div>
  </div>
</div>

<!-- STEP 2: INTERACTION PROMPT -->
<div id="step2wrap" style="display:none">
<div class="sim-divider">Step 2 — Interaction Design Prompt</div>
<div class="sim-prompt">
<pre><span class="hl">Base prompt stays unchanged.</span> Addition:

<span class="hl2">TASK — INTERACTIONS</span>
<span class="hl3">Add the following transitions:
· Headline: fade in, 300ms ease-out, delay 100ms
· CTA button: slide up 16px → 0, 250ms ease-out, delay 200ms
· Active progress dot: pulse animation, 1.5s loop

Brand motion rule: ease-out only. Never stacked. Never bouncy.</span></pre>
</div>
<button class="sim-btn sim-btn2" id="btn2" onclick="runStep2()">&#9654; Add interactions</button>

<!-- PROCESSING 2 -->
<div class="sim-proc" id="proc2">
  <span class="dot"></span><span class="dot"></span><span class="dot"></span>
  Applying animations…
</div>

<!-- OUTPUT 2 -->
<div class="sim-out" id="out2">
  <div class="phone-wrap">
    <div class="phone">
      <div class="phone-bar"><div class="phone-bar-dot"></div></div>
      <div class="phone-screen" id="animScreen">
        <div class="sc-progress">
          <div class="sc-dot active anim" id="animDot"></div>
          <div class="sc-dot"></div>
          <div class="sc-dot"></div>
        </div>
        <div class="sc-icon">🌿</div>
        <div class="sc-title anim" id="animTitle">Find your calm.</div>
        <div class="sc-body">Three minutes a day is all it takes. No prior experience needed.</div>
        <div class="sc-cta anim" id="animCta">Get Started</div>
        <div class="sc-skip">Skip for now</div>
      </div>
    </div>
  </div>
  <div class="annots">
    <div class="annot done"><div class="annot-head">Headline fade in</div><div class="annot-body">300ms ease-out · delay 100ms · taken directly from the prompt.</div><span class="annot-tag">✓ Spec applied</span></div>
    <div class="annot done"><div class="annot-head">CTA slide up</div><div class="annot-body">16px → 0 · 250ms ease-out · delay 200ms · within thumb reach.</div><span class="annot-tag">✓ Brand motion rules</span></div>
    <div class="annot done"><div class="annot-head">Progress dot pulse</div><div class="annot-body">1.5s loop · signals active step without distraction.</div><span class="annot-tag">✓ Ease-out · not bouncy</span></div>
    <div class="annot done"><div class="annot-head">No stacked motion</div><div class="annot-body">All delays staggered — no two animations starting simultaneously.</div><span class="annot-tag">✓ Brand rule</span></div>
  </div>
</div>
<button id="btn3" style="display:none;background:none;border:1px solid #e0e0e0;border-radius:8px;padding:10px 18px;font-size:13px;color:#666;cursor:pointer;margin-top:8px" onclick="replayAnim()">↺ Replay animation</button>
</div>

</div><!-- /sim -->

<script>
function runStep1(){
  document.getElementById('btn1').disabled=true;
  document.getElementById('proc1').classList.add('active');
  setTimeout(function(){
    document.getElementById('proc1').classList.remove('active');
    document.getElementById('out1').classList.add('active');
    document.getElementById('step2wrap').style.display='block';
    document.getElementById('step2wrap').scrollIntoView({behavior:'smooth',block:'nearest'});
  },1800);
}
function runStep2(){
  document.getElementById('btn2').disabled=true;
  document.getElementById('proc2').classList.add('active');
  setTimeout(function(){
    document.getElementById('proc2').classList.remove('active');
    document.getElementById('out2').classList.add('active');
    document.getElementById('btn3').style.display='inline-block';
    replayAnim();
  },2000);
}
function replayAnim(){
  var els=['animTitle','animCta','animDot'];
  els.forEach(function(id){
    var el=document.getElementById(id);
    el.style.animation='none';
    el.offsetHeight;
    el.style.animation='';
  });
}
</script>


The Browser and the Design System

Tools like Cursor can now read design systems directly from Figma – every token, component, spacing rule, and variant. When you prompt inside that environment, the AI works within the same constraints you would reach for in Figma. The result: an interface described in natural language, built against the real design system, production-ready. No handoff. No three-sprint feedback loop.

This changes what a design system is for. It was always a bridge between designers and developers. In an AI-assisted workflow it becomes a ruleset for the model. The more precisely it’s documented – not just what exists, but why – the better the AI applies it without drift.

The shift is from picking components to teaching a model how to pick them.
 

What Doesn’t Transfer

Spatial intuition – the instinct for when something feels too dense, when a layout needs breathing room – is still difficult to encode. The eye is still necessary.

Quality ownership is real. In a traditional workflow, a developer catches things. In a browser-first workflow, if nobody with a critical eye reviews the output, errors ship. Speed only works if someone is still asking whether the result is actually right.

And prompting well takes practice. Knowing what to describe, at what level of detail, to get useful output – that is a skill that develops through iteration, the same way research skills do.

None of these gaps are reasons not to use the tools. They are reasons to stay in the loop. The eye, the judgment, and the ownership do not transfer to the AI. They stay with you.
 

The Risk: UI Without UX

The tools are now accessible to everyone. A product manager, a developer, a founder can produce a polished UI screen in minutes. Right components. Right tokens. Presented as a design proposal.

UI is a screen. A transition. A component in a visual state. UX is the journey – the sequence of decisions, mental models, and goals that determine whether a user can move through a product and complete what they came to do. These are not the same thing. And fast UI production does not close that gap. It widens it, invisibly.

A polished screen does not mean the user understands the journey. It means the screen renders correctly. Only one of those measurements is visible in a design review.

When organisations accumulate screens without the research layer, the journey is not designed – it is assembled. Each screen looks complete. The whole doesn’t hold together. And the conversations that follow – defending, explaining, reworking – take far longer than the prompt that caused them.

This is also where the work continues after the prompt. User testing. A/B testing. Accessibility QA. Research that feeds back into the next iteration. The gap to technology is smaller. The gap to the user is exactly the same size it has always been – and that is the designer’s permanent territory.
 

The Handoff Was Always the Weak Point

The dev handoff was never clean. It was design intent compressed into documents that developers interpreted, sometimes correctly, often approximately.

AI tools are not solving the handoff. They are making it optional.

Designers who step into that space will own more of the product experience than they ever have. Designers who don’t will hand that ownership to whoever does.

UX Prompt Design is not a new skill added to a long list. It is the next version of the same thinking – applied to a canvas that is faster, more direct, and closer to the user than anything before it.

The question is not whether to learn it. The question is whether you learn it before someone else defines it for you.
 

Sources & Further Reading

• Nielsen Norman Group. State of UX 2026: Design Deeper to Differentiate. On the widening gap between AI capability and design quality.
• 925Studios. Why Prompt Design Is Now a Core UX Skill in 2026. On information architecture and UX writing as prompt foundations.
• AI UX Playground. Why UX Designers Are Ditching Figma for Cursor. On browser-first design workflows connected to design systems.
• Design Systems Collective. Set Up Code Connect with Cursor. Connecting Figma design systems to AI tools via MCP.
• Smashing Magazine. When “Production-Ready” Becomes a Design Deliverable. On UX designers owning implementation in AI-assisted workflows.
• LogRocket. Design Engineering Then vs. Now. How AI is reshaping the designer–developer divide.

Companies laid off workers to save money. Then the AI bill arrived — and it was higher than the salaries they had just cut. This is the story of tokenmaxxing: what it is, what it revealed, and what it means for companies that have not caught up yet.

Key Takeaways

The most powerful AI tools are expensive — expensive enough that, for most jobs, keeping a human is still cheaper. Tokenmaxxing — measuring how many AI operations your team triggers instead of how good the results are — burned through budgets and exposed an uncomfortable truth: most companies do not know what good AI use actually looks like. For Germany, which is still catching up on AI adoption, there is a rare chance to skip the expensive mistakes — but only if companies know what to avoid.

The Leaderboard Nobody Questioned

Meta (the company behind Facebook and Instagram) built an internal competition called Claudeonomics. All 85,000 employees could see a live ranking of who was consuming the most AI. Top users earned titles like “Token Legend” and “Session Immortal.” The bottom of the list was visible too.

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

Think about what that leaderboard actually rewarded. Not the best output. Not the most useful work. The highest token consumption. An employee who ran the same prompt ten times appeared more productive than one who asked once, got it right, and moved on. The incentive was not to work well with AI — it was to use as much AI as possible, as visibly as possible, to avoid appearing at the bottom of a company-wide ranking seen by 85,000 colleagues.

In one month, Meta consumed between 60 and 73 trillion tokens. The estimated cost ran into the hundreds of millions per month, heading toward billions annually. Nobody in the programme was asking whether those tokens produced anything worth that price. The metric was volume. Volume was climbing. The programme was, by its own measure, a success.

The leaderboard was shut down 48 hours after the numbers leaked to the press. Not because the costs were wrong. Because once the numbers were public, the question became unavoidable: what exactly did all of that buy?

Around the same time, Uber rolled out an AI coding assistant to around 5,000 engineers. No leaderboard — just a tool that billed by usage. Average monthly costs ran $150–$250 per engineer, with heavy users reaching $500 to $2,000 per month. By April 2026, Uber had spent its entire AI budget for the year — with eight months still to go. No competition required. The wrong incentive structure produces the same result either way.

What Tokenmaxxing Actually Is

A token is the basic unit AI systems use to process text — roughly three-quarters of a word. Every message you send and every answer you receive consumes tokens. Automated AI tasks running in the background (so-called agentic workflows, where the AI works through a series of steps on its own) can consume enormous numbers of tokens without anyone noticing — or approving the spend.

Tokenmaxxing is what happens when companies start treating token volume as a sign of productivity. The more AI operations your team triggers, the more “efficient” they appear. This sounds like a small measurement error. It is not. When volume becomes the main goal (the KPI — Key Performance Indicator), people stop asking whether the output was actually good and start optimising to use more AI, whether it helps or not.

The Bill Nobody Showed You

Not all AI models cost the same. The price gap between mainstream models is up to 300× — from $0.10 per million tokens (cheap, fast models like Gemini Flash-Lite or GPT-4.1 nano) to $30 per million output tokens (powerful flagship models like GPT-5.6). The most capable models — so-called frontier models (the best-performing AI systems available) — like Claude Opus 4.8 sit at $5 input / $25 output per million tokens.

Reasoning models (AI systems that think through a problem step by step before answering) add a hidden layer of cost: those internal thinking steps are billed even though you never see them. A short response can quietly generate ten times more tokens behind the scenes.

Per-token prices have dropped around 98% since 2022 — but enterprise AI bills have tripled over the same period. Lower unit prices were swallowed by far higher consumption, driven by automated workflows that run continuously in the background.

Cost Map: Tokens, Humans & Design Systems

The following overview shows how AI tool costs compare to human salaries in design roles, what happens when a design system is missing, and how Figma’s role has shifted as a result.

<div style="font-family:inherit;max-width:100%;margin:48px 0;">
<style scoped>
.nwx-stats{display:grid;grid-template-columns:repeat(4,1fr);gap:12px;margin-bottom:36px}
.nwx-stat{background:#f5f5f5;border-radius:10px;padding:20px 14px;text-align:center}
.nwx-num{font-size:30px;font-weight:800;line-height:1;color:#212121}
.nwx-num.red{color:#212121}.nwx-num.green{color:#333333}
.nwx-lbl{font-size:12px;color:#888;margin-top:7px;line-height:1.4}
.tbl-wrap{overflow-x:auto;-webkit-overflow-scrolling:touch;margin-bottom:10px}
.nwx-tbl{width:100%;min-width:580px;border-collapse:collapse;font-size:13px}
.nwx-tbl th{background:#212121;color:#fff;padding:10px 14px;text-align:left;font-size:12px;font-weight:700;letter-spacing:.05em;text-transform:uppercase;white-space:nowrap}
.nwx-tbl th:not(:first-child){text-align:center}
.nwx-tbl td{padding:10px 14px;border-bottom:1px solid #f0f0f0;vertical-align:middle;line-height:1.4}
.nwx-tbl td:not(:first-child){text-align:center;white-space:nowrap}
.nwx-tbl tr:last-child td{border-bottom:none}
.nwx-tbl tr:nth-child(even) td{background:#fafafa}
.nwx-tbl tr.hl td{background:#f5f5f5;font-weight:600}
.bdg{display:inline-block;padding:2px 8px;border-radius:20px;font-size:12px;font-weight:700;letter-spacing:.04em;text-transform:uppercase}
.b-lo{background:#f0f0f0;color:#333333}.b-mi{background:#f5f5f5;color:#666666}
.b-hi{background:#f0f0f0;color:#212121}.b-key{background:#212121;color:#fff}
.rl{font-weight:600;color:#212121;font-size:13px}.rs{font-size:12px;color:#888;font-weight:400;margin-top:2px}
.src{font-size:12px;color:#aaa;text-align:right;margin-bottom:28px}
.dg{display:grid;grid-template-columns:repeat(3,1fr);gap:12px;margin-bottom:36px}
.dc{border:1px solid #e0e0e0;border-radius:10px;padding:18px}
.dc.dep{border-color:#333333}
.dt{font-size:12px;font-weight:700;letter-spacing:.08em;text-transform:uppercase;margin-bottom:8px}
.dt.none{color:#212121}.dt.sha{color:#666666}.dt.dep{color:#333333}
.dn{font-size:15px;font-weight:700;color:#212121;margin-bottom:12px}
.dm{display:flex;justify-content:space-between;align-items:center;padding:5px 0;border-top:1px solid #f0f0f0;font-size:12px;color:#555}
.dm:first-of-type{border-top:none;margin-top:8px}
.dv{font-weight:700;font-size:13px}.dv.bad{color:#212121}.dv.ok{color:#666666}.dv.good{color:#333333}
.dv.est{font-style:italic;font-weight:400}
.dbw{height:4px;background:#f0f0f0;border-radius:2px;margin:14px 0 0}
.db{height:4px;border-radius:2px}
.fg{display:grid;grid-template-columns:1fr 44px 1fr;gap:0;margin-bottom:28px;align-items:start}
.fc{border:1px solid #e0e0e0;border-radius:10px;padding:18px}
.fc.af{border-color:#212121}
.fe{font-size:12px;font-weight:700;letter-spacing:.08em;text-transform:uppercase;margin-bottom:8px}
.fe.be{color:#888}.fe.af{color:#212121}
.ft{font-size:15px;font-weight:700;margin-bottom:14px}
.fi{font-size:12px;color:#555;padding:5px 0;border-top:1px solid #f0f0f0;display:flex;align-items:flex-start;gap:8px;line-height:1.4}
.fi:first-of-type{border-top:none}
.fd{width:6px;height:6px;border-radius:50%;flex-shrink:0;margin-top:5px}
.fd.gr{background:#bbb}.fd.dk{background:#212121}
.farr{display:flex;align-items:center;justify-content:center;color:#888;font-size:22px;padding-top:22px}
.dk-box{background:#212121;border-radius:10px;padding:24px 28px;margin-top:8px;border-left:4px solid #fff}
.dk-h{font-size:16px;font-weight:800;color:#fff;line-height:1.4;margin-bottom:8px}
.dk-b{font-size:13px;color:#aaa;line-height:1.6}
.sl{font-size:12px;font-weight:700;letter-spacing:.1em;text-transform:uppercase;color:#888;margin-bottom:10px;margin-top:32px}
.st{font-size:18px;font-weight:800;color:#212121;margin-bottom:4px}
.ss{font-size:13px;color:#666;margin-bottom:20px;line-height:1.5}
hr.nwx{border:none;border-top:1px solid #f0f0f0;margin:28px 0}
.fn{font-size:12px;color:#bbb;margin-top:6px;margin-bottom:24px}

@media(max-width:640px){
  .nwx-stats{grid-template-columns:repeat(2,1fr)}
  .dg{grid-template-columns:1fr}
  .fg{grid-template-columns:1fr;gap:12px}
  .farr{transform:rotate(90deg);padding:0}
  .src{text-align:left}
}
@media(max-width:360px){
  .nwx-stats{grid-template-columns:1fr}
}
</style>

<div class="sl">The numbers</div>
<div class="nwx-stats">
  <div class="nwx-stat"><div class="nwx-num green">&#8722;98%</div><div class="nwx-lbl">Token price drop since 2022</div></div>
  <div class="nwx-stat"><div class="nwx-num red">3&times;</div><div class="nwx-lbl">Enterprise AI bills tripled same period</div></div>
  <div class="nwx-stat"><div class="nwx-num red">11.7%</div><div class="nwx-lbl">Jobs where AI is cost-competitive with humans (MIT, 2025)</div></div>
  <div class="nwx-stat"><div class="nwx-num">300&times;</div><div class="nwx-lbl">Price spread across mainstream models (July 2026)</div></div>
</div>

<hr class="nwx">

<div class="sl">Cost comparison</div>
<div class="st">Human vs. AI in design workflows</div>
<div class="ss">Monthly gross cost estimates &middot; Germany &middot; 2026 &middot; Sources: Glassdoor, PayScale, Anthropic, Cursor</div>

<div class="tbl-wrap">
<table class="nwx-tbl">
<thead><tr>
  <th style="width:28%">Scenario</th>
  <th style="width:16%">Monthly cost</th>
  <th style="width:18%">Quality layer?</th>
  <th style="width:18%">Token risk</th>
  <th style="width:20%">Design system</th>
</tr></thead>
<tbody>
<tr><td><div class="rl">Junior UX Designer</div><div class="rs">Human &middot; 0&ndash;3 years &middot; Germany gross</div></td><td>&#8364;3,300&ndash;4,400</td><td><span class="bdg b-lo">Built in</span></td><td><span class="bdg b-lo">None</span></td><td><span class="bdg b-mi">Helpful</span></td></tr>
<tr><td><div class="rl">Senior UX Designer</div><div class="rs">Human &middot; 8+ years &middot; Germany gross</div></td><td>&#8364;6,300&ndash;7,900</td><td><span class="bdg b-lo">Built in</span></td><td><span class="bdg b-lo">None</span></td><td><span class="bdg b-mi">Helpful</span></td></tr>
<tr><td><div class="rl">AI &ndash; Entry stack</div><div class="rs">Claude Pro $20 + Figma Pro $20</div></td><td>$40&ndash;80</td><td><span class="bdg b-hi">Missing</span></td><td><span class="bdg b-mi">Moderate</span></td><td><span class="bdg b-hi">Critical</span></td></tr>
<tr><td><div class="rl">AI &ndash; Professional stack</div><div class="rs">Claude Max 5x + Figma + Cursor Pro</div></td><td>$140&ndash;160</td><td><span class="bdg b-hi">Missing</span></td><td><span class="bdg b-mi">Moderate</span></td><td><span class="bdg b-hi">Critical</span></td></tr>
<tr><td><div class="rl">AI &ndash; Heavy / agentic</div><div class="rs">Claude Max 20x + Cursor Ultra + API</div></td><td>$400&ndash;2,000+</td><td><span class="bdg b-hi">Missing</span></td><td><span class="bdg b-hi">High</span></td><td><span class="bdg b-hi">Critical</span></td></tr>
<tr class="hl"><td><div class="rl">AI + Human QA layer</div><div class="rs">Prompt architect + reviewer + iteration</div></td><td>$140&ndash;160 + time</td><td><span class="bdg b-key">Restored</span></td><td><span class="bdg b-lo">Low</span></td><td><span class="bdg b-lo">Multiplier</span></td></tr>
<tr class="hl"><td><div class="rl">AI + Deep design system</div><div class="rs">Figma MCP-connected &middot; full token + rule docs</div></td><td>$140&ndash;160 + maintenance</td><td><span class="bdg b-key">Embedded</span></td><td><span class="bdg b-lo">Minimal</span></td><td><span class="bdg b-key">Foundation</span></td></tr>
</tbody>
</table>
</div>
<div class="src">Sources: Glassdoor DE 2026 &middot; PayScale DE 2026 &middot; Anthropic pricing &middot; Cursor pricing &middot; Uber/Forbes 2026</div>

<hr class="nwx">

<div class="sl">Design system depth</div>
<div class="st">How depth changes every downstream cost</div>
<div class="ss">The design system is the multiplier. The more precisely it defines what exists and why, the better every AI output &mdash; and the fewer correction tokens burned.</div>

<div class="dg">
  <div class="dc">
    <div class="dt none">No system</div>
    <div class="dn">AI guesses everything</div>
    <div class="dm"><span>Token cost per output</span><span class="dv bad">Very high</span></div>
    <div class="dm"><span>Correction rounds</span><span class="dv bad est">Many (est.)</span></div>
    <div class="dm"><span>Brand consistency</span><span class="dv bad">None</span></div>
    <div class="dm"><span>Accessibility compliance</span><span class="dv bad">Manual audit</span></div>
    <div class="dm"><span>Pixel-pushing needed</span><span class="dv bad">~100%</span></div>
    <div class="dm"><span>Figma strategic value</span><span class="dv ok">Low</span></div>
    <div class="dbw"><div class="db" style="width:15%;background:#212121;"></div></div>
  </div>
  <div class="dc">
    <div class="dt sha">Shallow system</div>
    <div class="dn">Basic tokens, some components</div>
    <div class="dm"><span>Token cost per output</span><span class="dv ok">Moderate</span></div>
    <div class="dm"><span>Correction rounds</span><span class="dv ok est">Moderate (est.)</span></div>
    <div class="dm"><span>Brand consistency</span><span class="dv ok">Partial</span></div>
    <div class="dm"><span>Accessibility compliance</span><span class="dv ok">Partial</span></div>
    <div class="dm"><span>Pixel-pushing needed</span><span class="dv ok">~50%</span></div>
    <div class="dm"><span>Figma strategic value</span><span class="dv ok">Medium</span></div>
    <div class="dbw"><div class="db" style="width:50%;background:#666666;"></div></div>
  </div>
  <div class="dc dep">
    <div class="dt dep">Deep system</div>
    <div class="dn">Full tokens &middot; rules &middot; rationale &middot; MCP</div>
    <div class="dm"><span>Token cost per output</span><span class="dv good">Low</span></div>
    <div class="dm"><span>Correction rounds</span><span class="dv good est">Few (est.)</span></div>
    <div class="dm"><span>Brand consistency</span><span class="dv good">Embedded</span></div>
    <div class="dm"><span>Accessibility compliance</span><span class="dv good">Embedded</span></div>
    <div class="dm"><span>Pixel-pushing needed</span><span class="dv good">&lt; 20%</span></div>
    <div class="dm"><span>Figma strategic value</span><span class="dv good">Highest</span></div>
    <div class="dbw"><div class="db" style="width:100%;background:#333333;"></div></div>
  </div>
</div>
<div class="fn">&#42; Correction rounds are practitioner estimates. No peer-reviewed study directly quantifies this relationship.</div>

<hr class="nwx">

<div class="sl">Figma&rsquo;s repositioning</div>
<div class="st">From everything-tool to source of truth</div>
<div class="ss">Figma is not dying. Its role is narrowing &mdash; and that narrower role is becoming structurally more important, not less.</div>

<div class="fg">
  <div class="fc">
    <div class="fe be">Figma before AI</div>
    <div class="ft">The everything-tool</div>
    <div class="fi"><div class="fd gr"></div>Wireframing &amp; ideation</div>
    <div class="fi"><div class="fd gr"></div>High-fidelity UI screens</div>
    <div class="fi"><div class="fd gr"></div>Prototyping &amp; flows</div>
    <div class="fi"><div class="fd gr"></div>Design system management</div>
    <div class="fi"><div class="fd gr"></div>Developer handoff</div>
    <div class="fi"><div class="fd gr"></div>Stakeholder presentation</div>
  </div>
  <div class="farr">&rarr;</div>
  <div class="fc af">
    <div class="fe af">Figma now (Config 2026)</div>
    <div class="ft">The canonical source of truth</div>
    <div class="fi"><div class="fd dk"></div><span><strong>MCP server</strong> &mdash; live context from GitHub, Slack, Atlassian, Notion</span></div>
    <div class="fi"><div class="fd dk"></div><span><strong>Code Connect</strong> &mdash; maps components to actual codebase</span></div>
    <div class="fi"><div class="fd dk"></div><span><strong>Code Layers</strong> &mdash; runnable code as first-class design object</span></div>
    <div class="fi"><div class="fd dk"></div><span><strong>Figma Motion</strong> &mdash; timeline + keyframes in design system</span></div>
    <div class="fi"><div class="fd dk"></div><span><strong>Design system as AI ruleset</strong> &mdash; tokens, constraints, rationale</span></div>
    <div class="fi" style="opacity:.5"><div class="fd gr"></div>Wireframing &rarr; commoditised (Claude Design, v0, Lovable)</div>
    <div class="fi" style="opacity:.5"><div class="fd gr"></div>Pixel UI &rarr; largely AI-generated</div>
  </div>
</div>

<div class="dk-box">
  <div class="dk-h">The deeper the design system, the less AI needs to guess &mdash; and the less it costs to get a correct output.</div>
  <div class="dk-b">Companies with deep, MCP-connected Figma design systems see token costs drop and output quality rise at the same time. Without one, every AI correction costs tokens, time, and brand drift &mdash; indefinitely.</div>
</div>

</div>

When AI Costs More Than the Workers It Replaced

Forbes, July 2, 2026: “AI Costs More Than The People It Replaced.” That was not a provocation. It was the market correcting a calculation error.

The original model looked obvious: replace a €85,000 salary with a €1,800 AI subscription — a 97% cost reduction on paper. The model had five rows missing. Oversight time for checking AI output (25–35% of capacity still required). Error correction — AI mistakes look plausible and take 2–3× longer to catch than obvious ones. Agentic token escalation — automated AI workflows use 10–100× more tokens than projected, as Microsoft discovered when it told engineers to stop using an AI coding tool entirely. Institutional knowledge that leaves with the person and cannot be reconstructed. And a rehire premium when companies reverse course — recruiter fees plus roughly six months to get someone back up to speed.

MIT’s Project Iceberg (November 2025, Massachusetts Institute of Technology) put a precise boundary on where the math actually works: AI is cost-competitive in roles covering 11.7% of the US workforce. For the other 88%, the evidence from 2025–2026 shows companies are now paying to find that out.

<div style="font-family:inherit;max-width:100%;margin:48px 0;">
<style scoped>
.ra-wrap{max-width:100%}
.ra-label{font-size:12px;font-weight:700;letter-spacing:.1em;text-transform:uppercase;color:#888;margin-bottom:8px}
.ra-title{font-size:18px;font-weight:800;color:#212121;margin-bottom:24px}

/* Apparent saving banner */
.ra-banner{background:#f0f0f0;border-radius:12px;padding:24px 28px;margin-bottom:24px;display:flex;align-items:center;gap:24px;flex-wrap:wrap}
.ra-banner-num{font-size:48px;font-weight:800;color:#333333;line-height:1;flex-shrink:0}
.ra-banner-text{}
.ra-banner-head{font-size:18px;font-weight:700;color:#212121;margin-bottom:4px}
.ra-banner-sub{font-size:13px;color:#555555;line-height:1.5}

/* Missing rows list */
.ra-missed-label{font-size:12px;font-weight:700;letter-spacing:.1em;text-transform:uppercase;color:#212121;margin:28px 0 12px}
.ra-row{display:flex;gap:16px;align-items:flex-start;padding:16px;border-radius:10px;background:#f0f0f0;margin-bottom:8px}
.ra-num{font-size:22px;font-weight:800;color:#212121;line-height:1;flex-shrink:0;width:28px;text-align:center;padding-top:2px}
.ra-body{flex:1}
.ra-row-head{font-size:14px;font-weight:700;color:#212121;margin-bottom:3px}
.ra-row-sub{font-size:13px;color:#666;line-height:1.5}
.ra-cost{font-size:14px;font-weight:800;color:#212121;white-space:nowrap;padding-top:2px;flex-shrink:0}

/* Total bar */
.ra-total{display:flex;justify-content:space-between;align-items:center;background:#212121;border-radius:10px;padding:18px 22px;margin:16px 0 28px;flex-wrap:wrap;gap:8px}
.ra-total-lbl{font-size:13px;color:#aaa}
.ra-total-val{font-size:22px;font-weight:800;color:#444444}

/* Summary 3-up */
.ra-cards{display:grid;grid-template-columns:repeat(3,1fr);gap:10px;margin-bottom:28px}
.ra-card{border-radius:10px;padding:18px;text-align:center}
.ra-card.app{background:#f0f0f0}
.ra-card.hid{background:#f0f0f0}
.ra-card.net{background:#212121}
.ra-card-lbl{font-size:12px;font-weight:700;letter-spacing:.08em;text-transform:uppercase;margin-bottom:8px}
.app .ra-card-lbl{color:#333333}
.hid .ra-card-lbl{color:#212121}
.net .ra-card-lbl{color:#888}
.ra-card-num{font-size:26px;font-weight:800;line-height:1}
.app .ra-card-num{color:#333333}
.hid .ra-card-num{color:#212121}
.net .ra-card-num{color:#fff}
.ra-card-sub{font-size:12px;margin-top:6px;line-height:1.4}
.app .ra-card-sub{color:#555555}
.hid .ra-card-sub{color:#444}
.net .ra-card-sub{color:#aaa}

/* Timeline */
.ra-tl{background:#f5f5f5;border-radius:12px;padding:22px;margin-bottom:12px}
.ra-tl-head{font-size:12px;font-weight:700;letter-spacing:.1em;text-transform:uppercase;color:#888;margin-bottom:16px}
.ra-bars{display:flex;gap:4px;align-items:flex-end;height:120px;margin-bottom:8px}
.ra-qtr{display:flex;flex-direction:column;align-items:center;gap:2px;flex:1}
.ra-qtr-bars{display:flex;gap:2px;align-items:flex-end;width:100%}
.ra-bar{border-radius:3px 3px 0 0;flex:1}
.ra-bar.ap{background:#e8e8e8}
.ra-bar.re{background:#444444}
.ra-bar.re.ok{background:#333333}
.ra-qlbl{font-size:12px;color:#999;margin-top:4px}
.ra-legend{display:flex;gap:20px;margin-top:8px;flex-wrap:wrap}
.ra-leg{display:flex;align-items:center;gap:6px;font-size:12px;color:#666}
.ra-leg-dot{width:12px;height:12px;border-radius:2px;flex-shrink:0}
.ra-note{font-size:12px;color:#bbb;line-height:1.6;margin-top:10px;font-style:italic}

@media(max-width:600px){
  .ra-cards{grid-template-columns:1fr}
  .ra-banner{gap:12px}
  .ra-banner-num{font-size:36px}
  .ra-total{flex-direction:column;gap:4px}
  .ra-row{flex-wrap:wrap}
  .ra-cost{margin-left:44px}
}
</style>

<div class="ra-wrap">
<div class="ra-label">The real arithmetic</div>
<div class="ra-title">What the calculation left out</div>

<div class="ra-banner">
  <div class="ra-banner-num">€151K</div>
  <div class="ra-banner-text">
    <div class="ra-banner-head">The apparent saving — per role, over 18 months</div>
    <div class="ra-banner-sub">Salary €85K/yr + employer contributions ~21% removed. AI stack added at €1,800/yr. This is the number that ended up in the boardroom slide. It is not wrong. It is missing five rows.</div>
  </div>
</div>

<div class="ra-missed-label">What the spreadsheet didn't include</div>

<div class="ra-row">
  <div class="ra-num">1</div>
  <div class="ra-body">
    <div class="ra-row-head">Oversight time</div>
    <div class="ra-row-sub">Every AI output needs to be checked and corrected by a real person — about 25–35% of the time the role was supposed to save. If that person is senior, it costs senior rates.</div>
  </div>
  <div class="ra-cost">~€36,000</div>
</div>

<div class="ra-row">
  <div class="ra-num">2</div>
  <div class="ra-body">
    <div class="ra-row-head">Error correction</div>
    <div class="ra-row-sub">AI mistakes look plausible. They slip past the first read and cost 2–3× more time to catch and fix than obvious human errors. IBM tested this: 6% of cases required full human intervention.</div>
  </div>
  <div class="ra-cost">~€18,000</div>
</div>

<div class="ra-row">
  <div class="ra-num">3</div>
  <div class="ra-body">
    <div class="ra-row-head">Runaway token costs</div>
    <div class="ra-row-sub">Automated AI task sequences (agentic workflows) use 10–100× more tokens than simple prompts. Microsoft stopped engineers from using an AI coding tool because the bills became unmanageable.</div>
  </div>
  <div class="ra-cost">~€14,000</div>
</div>

<div class="ra-row">
  <div class="ra-num">4</div>
  <div class="ra-body">
    <div class="ra-row-head">Lost institutional knowledge</div>
    <div class="ra-row-sub">When the person leaves, the understanding of why past decisions were made leaves too. No AI can reconstruct it. It surfaces months later as repeated mistakes and contradictory choices.</div>
  </div>
  <div class="ra-cost">unquantified</div>
</div>

<div class="ra-row">
  <div class="ra-num">5</div>
  <div class="ra-body">
    <div class="ra-row-head">Rehire premium when the reversal comes</div>
    <div class="ra-row-sub">29% of companies that cut roles for AI rehired within 18 months — under urgency. Recruiter fees add 15–25% of annual salary. Getting the person productive again takes around 6 months of management time on top.</div>
  </div>
  <div class="ra-cost">~€65,000</div>
</div>

<div class="ra-total">
  <div class="ra-total-lbl">Total hidden costs over 18 months (per role)</div>
  <div class="ra-total-val">€133,000+</div>
</div>

<div class="ra-cards">
  <div class="ra-card app">
    <div class="ra-card-lbl">Apparent saving</div>
    <div class="ra-card-num">€151K</div>
    <div class="ra-card-sub">What the boardroom slide showed</div>
  </div>
  <div class="ra-card hid">
    <div class="ra-card-lbl">Hidden costs</div>
    <div class="ra-card-num">€133K+</div>
    <div class="ra-card-sub">Not in the original model</div>
  </div>
  <div class="ra-card net">
    <div class="ra-card-lbl">Real net saving</div>
    <div class="ra-card-num">€0–18K</div>
    <div class="ra-card-sub">Before quality damage and knowledge loss</div>
  </div>
</div>

<div class="ra-tl">
  <div class="ra-tl-head">How the gap closes — cumulative costs per replaced role over 18 months</div>
  <div class="ra-bars" id="ra-chart"></div>
  <div class="ra-legend">
    <div class="ra-leg"><div class="ra-leg-dot" style="background:#e8e8e8;border:1px solid #333333"></div><span>Projected saving</span></div>
    <div class="ra-leg"><div class="ra-leg-dot" style="background:#444444"></div><span>Actual total cost (incl. hidden)</span></div>
  </div>
  <div class="ra-note">* Q5 spike = typical rehire event at 15-month mark. Institutional knowledge loss excluded — no reliable method to quantify.</div>
</div>

</div>
<script>
(function(){
  var el=document.getElementById('ra-chart');if(!el)return;
  var proj=[17,34,50,67,84,101];
  var real=[5,13,25,43,108,133];
  var max=133,H=120;
  var html='',ql=['Q1','Q2','Q3','Q4','Q5','Q6'];
  for(var i=0;i<6;i++){
    var ph=Math.round(proj[i]/max*H);
    var rh=Math.round(real[i]/max*H);
    var rc=real[i]<=proj[i]?'ok':'';
    html+='<div class="ra-qtr"><div class="ra-qtr-bars">';
    html+='<div class="ra-bar ap" style="height:'+ph+'px"></div>';
    html+='<div class="ra-bar re '+rc+'" style="height:'+rh+'px"></div>';
    html+='</div><div class="ra-qlbl">'+ql[i]+'</div></div>';
  }
  el.innerHTML=html;
})();
</script>
</div>

The Boomerang: Why the Layoff Logic Is Reversing

Klarna (a Swedish payments company) announced in 2024 that its AI agent could do the work of 700 customer service employees. It made international headlines. Then, quietly, Klarna started hiring customer service staff back — no press release, no correction to the original headline.

Ford rehired 350 veteran engineers to fix quality problems that automated systems could not catch. Their conclusion: giving AI design requirements does not produce a quality product without experienced human oversight.

These are not exceptions. They are the pattern. IBM replaced large parts of its HR department with AI that handled 94% of routine requests without issues. The remaining 6% — ethical decisions, complex escalations, judgment calls — broke the process. IBM subsequently announced plans to triple its US entry-level hiring.

55% of executives now regret replacing human workers with AI. 73% of organisations that made AI-driven cuts failed to improve their financial results. 29% have already rehired for the exact positions they eliminated.

For most organisations, the assumption that AI makes people obsolete has already been tested — and failed.

<div style="font-family:inherit;max-width:100%;margin:48px 0;">
<style scoped>
.pf-wrap{max-width:100%}
.pf{display:flex;gap:0;align-items:stretch}
.pf-phase{flex:1;display:flex;flex-direction:column}
.pf-label{font-size:12px;font-weight:700;letter-spacing:.08em;text-transform:uppercase;text-align:center;padding:8px 6px;border-radius:6px 6px 0 0}
.pf-label.ph1{background:#333333;color:#fff}
.pf-label.ph2{background:#666666;color:#fff}
.pf-label.ph3{background:#212121;color:#fff}
.pf-label.ph4{background:#333333;color:#fff}
.pf-cards{display:flex;flex-direction:column;gap:4px;padding:4px;flex:1}
.pf-card{background:#f5f5f5;border-radius:6px;padding:10px 12px;font-size:13px;line-height:1.5;color:#333}
.pf-card.dark{background:#212121;color:#fff}
.pf-card.warn{background:#f5f5f5;border-left:3px solid #666666}
.pf-card.danger{background:#f0f0f0;border-left:3px solid #212121}
.pf-card.good{background:#f0f0f0;border-left:3px solid #333333}
.pf-card strong{display:block;font-size:12px;font-weight:700;margin-bottom:3px}
.pf-arrow{display:flex;align-items:center;justify-content:center;padding:0 6px;font-size:20px;color:#bbb;flex-shrink:0;margin-top:28px}
.pf-stat{text-align:center;padding:10px 4px;font-size:20px;font-weight:800;color:#212121;margin-top:auto}
.pf-stat span{display:block;font-size:12px;font-weight:400;color:#888;margin-top:2px;line-height:1.3}

.bm-stats{display:flex;gap:10px;margin-top:24px;flex-wrap:wrap}
.bm-stat{flex:1;min-width:130px;background:#f5f5f5;border-radius:10px;padding:16px;text-align:center}
.bm-num{font-size:28px;font-weight:800;color:#212121;line-height:1}
.bm-num.ok{color:#333333}
.bm-lbl{font-size:12px;color:#666;margin-top:6px;line-height:1.4}

.case-row{display:grid;grid-template-columns:repeat(3,1fr);gap:10px;margin-top:16px}
.case{border:1px solid #e0e0e0;border-radius:8px;padding:14px}
.case-co{font-size:14px;font-weight:700;color:#212121;margin-bottom:6px}
.case-txt{font-size:13px;color:#555;line-height:1.5}
.case-tag{display:inline-block;margin-top:8px;padding:2px 8px;border-radius:20px;font-size:12px;font-weight:700;background:#f0f0f0;color:#333333}

.sl{font-size:12px;font-weight:700;letter-spacing:.1em;text-transform:uppercase;color:#888;margin-bottom:10px}
.st{font-size:18px;font-weight:800;color:#212121;margin-bottom:16px}

@media(max-width:640px){
  .pf{flex-direction:column;gap:0}
  .pf-arrow{margin-top:0;transform:rotate(90deg);padding:4px 0;font-size:18px}
  .pf-label{border-radius:6px 6px 0 0}
  .case-row{grid-template-columns:1fr}
  .bm-stats{gap:8px}
  .bm-stat{min-width:calc(50% - 4px)}
}
</style>

<div class="pf-wrap">
<div class="sl">The logic that failed — step by step</div>
<div class="st">From cost promise to boomerang</div>

<div class="pf">

  <div class="pf-phase">
    <div class="pf-label ph1">Phase 1 &middot; The Promise</div>
    <div class="pf-cards">
      <div class="pf-card dark"><strong>The headline</strong>"AI can do this for a fraction of the cost."</div>
      <div class="pf-card"><strong>The decision</strong>Lay off human workers. Redirect the salary budget to AI tools.</div>
      <div class="pf-card"><strong>The assumption</strong>AI output = human output, at lower cost.</div>
      <div class="pf-stat">39%<span>of business leaders cut employees for AI</span></div>
    </div>
  </div>

  <div class="pf-arrow">&rarr;</div>

  <div class="pf-phase">
    <div class="pf-label ph2">Phase 2 &middot; Tokenmaxxing</div>
    <div class="pf-cards">
      <div class="pf-card warn"><strong>Volume as the goal</strong>Token use tracked as productivity. Leaderboards. Adoption targets.</div>
      <div class="pf-card warn"><strong>Budget shock</strong>Prices fell 98%. Bills tripled anyway. Automated workflows used far more than planned.</div>
      <div class="pf-card warn"><strong>No quality check</strong>The person who would review and catch errors is gone.</div>
      <div class="pf-stat" style="color:#666666">3&times;<span>enterprise AI bills tripled while token prices fell</span></div>
    </div>
  </div>

  <div class="pf-arrow">&rarr;</div>

  <div class="pf-phase">
    <div class="pf-label ph3">Phase 3 &middot; The Failure</div>
    <div class="pf-cards">
      <div class="pf-card danger"><strong>Quality collapses</strong>AI output looks right until it ships. Errors go unchecked.</div>
      <div class="pf-card danger"><strong>Costs exceed the saving</strong>AI + oversight + rework costs more than the salary it replaced.</div>
      <div class="pf-card danger"><strong>The 6% problem</strong>AI handles routine well. Judgment and ethics it cannot — and that 6% breaks the system.</div>
      <div class="pf-stat">73%<span>of AI-driven layoff companies failed to improve financially</span></div>
    </div>
  </div>

  <div class="pf-arrow">&rarr;</div>

  <div class="pf-phase">
    <div class="pf-label ph4">Phase 4 &middot; The Boomerang</div>
    <div class="pf-cards">
      <div class="pf-card good"><strong>The reversal</strong>Companies rehire for the exact roles they eliminated. Quietly. No press releases.</div>
      <div class="pf-card good"><strong>The lesson</strong>AI completes tasks. It does not complete jobs. Human judgment is not optional.</div>
      <div class="pf-card good"><strong>The new model</strong>AI + human quality layer. Precise prompting. A design system. Token spend tracked as a real cost.</div>
      <div class="pf-stat" style="color:#333333">29%<span>already rehired for the roles they cut</span></div>
    </div>
  </div>

</div>

<div class="sl" style="margin-top:32px">The numbers that confirm it</div>
<div class="bm-stats">
  <div class="bm-stat"><div class="bm-num">55%</div><div class="bm-lbl">of executives regret replacing workers with AI</div></div>
  <div class="bm-stat"><div class="bm-num">73%</div><div class="bm-lbl">of AI-layoff companies failed to improve financially</div></div>
  <div class="bm-stat"><div class="bm-num">29%</div><div class="bm-lbl">already rehired for the exact positions they cut</div></div>
  <div class="bm-stat"><div class="bm-num ok">32%</div><div class="bm-lbl">of hiring managers who cut roles for AI later rehired for the same position</div></div>
</div>

<div class="sl" style="margin-top:28px">Who came back first</div>
<div class="case-row">
  <div class="case">
    <div class="case-co">Klarna</div>
    <div class="case-txt">Announced AI replaced 700 customer service staff. Made global headlines. Then quietly started rehiring as quality problems mounted.</div>
    <div class="case-tag">Quietly rehiring</div>
  </div>
  <div class="case">
    <div class="case-co">Ford</div>
    <div class="case-txt">Rehired 350 veteran engineers to fix quality problems automated systems couldn't catch. VP Engineering: "We wrongly assumed AI could replace experienced human oversight."</div>
    <div class="case-tag">350 engineers back</div>
  </div>
  <div class="case">
    <div class="case-co">IBM</div>
    <div class="case-txt">AI handled 94% of HR requests fine. Failed at the 6% needing ethical judgment. IBM subsequently announced plans to triple US entry-level hiring in 2026.</div>
    <div class="case-tag">Tripling entry hires</div>
  </div>
</div>
</div>
</div>

Token Loyalty: The New Corporate Obedience

When volume becomes the goal, a new kind of employee behaviour emerges: token loyalty. Not loyalty to the work. Loyalty to the metric. People optimise for what is measured, regardless of whether it produces anything useful. The person at the top of the leaderboard did not necessarily do the best work — they most completely handed their thinking to the machine.

This is the deeper problem behind the leaderboard: a company with 85,000 employees could not define what good AI use looks like. So it measured the only thing it could count — and built a culture around it.

The Skill Nobody Is Protecting

When people stop doing parts of their job and hand them to AI, those skills do not stay sharp. The ability to evaluate whether an output is actually correct — not just plausible-sounding — comes from practice. Tokenmaxxing optimises for volume. It does not reward that judgment.

The long-term risk: employees who outsourced the most are now least equipped to know when AI gets it wrong. They delegated before they developed the ability to evaluate. Now they cannot reliably tell the difference between a correct answer and a confident-sounding mistake.

What This Means for Germany

Germany is typically a second mover on new technology. According to Bitkom (Germany’s digital industry association), only 26% of German companies currently give employees access to AI tools. That sounds like a disadvantage — and in some ways it is.

But there is another reading: while US companies spent 2025–2026 learning expensive lessons, most German companies were still writing their AI strategy documents. They did not go through the costly phase, because they had not started yet. That is a rare chance to do it right — if they avoid simply importing the US playbook, delays and all.

Germany also has structural safeguards most US companies lack. Works councils (Betriebsrat) have a legal right under §90 BetrVG (the German Works Constitution Act, which sets out employee participation rights) to be informed and consulted before AI systems are introduced in the workplace. A works council that understands what it is looking at can prevent tokenmaxxing-style programmes before they are ever launched. That is not bureaucracy. That is governance that works.

The EU AI Act — in full effect from August 2026, requiring AI systems to be classified by risk, documented, and made transparent — adds further obligations. Companies rolling out AI without governance will have to retrofit compliance under time pressure. Building it in from the start costs less.

Figma, Claude Design & the Source of Truth

Anthropic (the company behind the Claude AI) launched Claude Design on April 17, 2026. It generates live, clickable web prototypes (interactive test versions of a website or app) from a plain text description — no design canvas, no dragging components around. Figma’s stock dropped 7% the day it launched. The conclusion many drew — that Figma is being replaced — was wrong.

Figma is not dying. Its role is narrowing, and that narrower role is becoming more important, not less. What is being automated away is generation: producing a user interface (UI — the buttons, screens, and menus users interact with) from a description. Claude Design, Cursor, v0, and Lovable all do this now. What cannot be automated is the canonical record — the single source of truth every AI tool reads to understand what “correct” looks like for your specific product.

Figma’s response was not to compete with Claude Design but to partner with Anthropic. Figma Config 2026 (June 23–25, San Francisco) made the direction explicit: a new MCP server (Model Context Protocol — lets AI tools read live context from GitHub, Slack, or Notion), Code Connect (links each Figma component directly to its real codebase counterpart), and Figma Motion (a built-in animation timeline). The message was clear: Figma is becoming the rulebook that all AI generation tools read from.

This has a direct cost implication. A designer with a well-documented, MCP-connected design system gives AI tools the context to get things right the first time. Fewer corrections mean fewer tokens and lower bills — the tokenmaxxing problem solved at the source.

What Comes Next

What we are living through right now has a name: the trough of disillusionment. Every major technology goes through it. The Gartner Hype Cycle (a well-known model that maps how technologies move from hype to reality) describes the pattern precisely: a peak of inflated expectations, followed by a crash when reality does not match the promise, followed eventually by a plateau where the technology is used in ways that actually work.

AI hit its peak somewhere around 2024. Tokenmaxxing leaderboards, mass layoffs, 97% cost-reduction slides — that was the top of the curve. The evidence of 2025–2026 — the failed financial outcomes, the rehiring waves, the bills that tripled while per-token prices fell — is the descent. This is not AI failing. This is the hype correcting itself.

The companies that come out ahead are the ones that use the disillusionment productively. Token spend is now treated as a real cost line (part of the P&L — Profit and Loss, i.e. the company’s financial bottom line), not just a usage report.

Salesforce CEO Marc Benioff introduced “agentic work units” as the new benchmark — and the concept is worth understanding, because it reflects exactly what the tokenmaxxing era got wrong. An agentic work unit is a completed, verifiable output: a support ticket resolved, a contract reviewed, a design iteration accepted, a bug fixed and tested. Not prompts sent. Not tokens consumed. Work done.

This reframes AI from a usage metric into a service with a price per outcome — and it puts the human back at the centre. Every work unit needs to be defined, accepted, and verified by someone who understands what good looks like. Tokenmaxxing removed that person. The agentic work unit model assumes they are there. That is what the plateau of the hype cycle looks like in practice.

Sources & Further Reading

• Forbes. AI Costs More Than The People It Replaced. July 2, 2026.
• Axios. AI can cost more than human workers now. April 2026.
• Fortune. Uber burned through its entire 2026 AI budget in four months. May 2026.
• Fortune. Microsoft reports are exposing AI’s real cost problem. May 2026.
• Forbes. After Tokenmaxxing, Token Spend Has Become the New Metric to Watch. July 10, 2026.
• Vucense. Meta’s Claudeonomics: 85,000 Employees Competing on AI Token Usage. 2026.
• MIT / Fortune. MIT Project Iceberg: AI can already replace nearly 12% of the U.S. workforce. November 2025.
• Great Learning. Tokenmaxxing Explained: The Hidden Cost of Workplace AI. 2026.
• Bitkom. KI-Nutzung in deutschen Unternehmen 2026. 2026.
• VentureBeat. Anthropic launches Claude Design, challenging Figma. April 2026.
• Figma Blog. Introducing the Figma MCP Server. 2026.
• BenchLM. LLM API Pricing Comparison July 2026. July 2026.
• CNBC. Employers who laid off workers for AI are reversing their decisions. July 1, 2026.
• Fast Company. The great AI layoff is turning into the great AI rehire. 2026.
• Forbes. Companies That Fired Workers for AI Now Want Them Back. May 21, 2026.
• IBTimes. AI Layoffs Backfire: 32% of Bosses Rehire Roles They Thought Robots Could Do. 2026.
• Futurism. Large Study Finds That Replacing Workers With AI Is Backfiring Badly. 2026.