AI productivity is becoming a team metric

Figma published its 2026 AI report — 8,403 survey responses and 639 interviews across ten markets — and the numbers describe a boundary dissolving in real time. Developer participation in design work jumped from 44% to 60% in a year. Designers doing development work nearly doubled, from 21% to 41%. Seventy percent of product builders say they use AI for tasks previously outside their skillset, over half say they've abandoned linear handoffs, and 41% now say AI has changed how their team works — up from 7% two years ago. Self-reported, survey-shaped, causality unproven, as Figma would concede. But the direction matches what anyone inside a product org can see from their desk.

The dissolving boundary is genuinely good news. It is also about to break every productivity dashboard built on individual output — because when everyone can create everything, creation stops being the scarce step.

Permission to create is not a shared standard

Here is what actually happens when a developer can generate screens and a designer can generate components. The developer ships a flow that is plausible and slightly off-system — spacing tokens improvised, a pattern that almost matches the design system's intent. The designer ships a component that works and subtly forks the codebase's conventions. Neither artifact is wrong enough to reject on sight, which is exactly the problem: each one now requires reconciliation — a design-system keeper deciding whether to absorb or correct the drift, a senior engineer deciding whether the fork is harmless. Multiply by everyone on the team, every sprint.

The boundary-crossing that AI enables grants permission to create across roles. It does not grant the shared quality standards, the taste, or the system knowledge that the boundary used to enforce by division of labor. Those still exist in a few heads — and the crossing traffic all routes through them.

The metrics that hide this, and the ones that don't

Individual output metrics — screens generated, PRs opened, tickets closed — are all rising, everywhere, mechanically. They measure the step AI just made free. Meanwhile the costs that determine whether the team ships faster are all coordination-shaped and none of them appear on an individual's dashboard: review queues lengthening because generated artifacts arrive faster than seniors can judge them; design-system drift accumulating as a hundred almost-right variants pile up; and decision latency — my quiet favorite — as the newly-empowered wait for someone to tell them which of three generated options is the real one.

rendering diagram…

This is the same bottleneck-shift I wrote about for code generation, now spread across the whole product org: accelerate one station and the queues downstream become the system. The scorecard that stays honest has five columns, all team-level: cycle time (idea to shipped, the only speed users feel), rework rate (how much generated work gets redone after review), review load (hours per senior per week — where the cost silently moved), escaped defects (whether speed degraded quality), and decision latency (median time from options-exist to option-chosen). Individual generation counts appear nowhere, on purpose.

What the fastest teams in the data are actually doing

The abandoned-linear-handoff finding is the one worth copying carefully. At work, the teams I see genuinely getting faster haven't just let everyone create — they have rebuilt the acceptance path to match. Three moves recur. They put the shared standard in the tools, not the review: design tokens enforced in code, lint rules for the system, agents configured with the conventions — so generated work arrives closer to right. They convert seniors from gatekeepers to samplers: trivial cross-boundary work auto-accepts against the encoded standard, and senior judgment concentrates on the cases that deserve it. And they give decisions a service level: someone owns "which option is real" per surface, with a clock on it, because three unblessed variants is negative inventory.

One client team this year did the opposite experiment for me, unintentionally: they enabled cross-role generation with great fanfare and changed nothing else. Individual output doubled inside a month. Cycle time got worse — review became the bottleneck, the design system forked in eleven places, and the two people who could arbitrate became the most oversubscribed calendar slots in the building. The fix wasn't limiting generation; it was funding the acceptance path — encoded standards, sampling review, named deciders — after which the same generation volume started converting into shipped work.

Steal this

Put the five team-level numbers on one page — cycle time, rework, review load, escaped defects, decision latency — and review them monthly next to the individual output charts everyone already celebrates. When output rises and cycle time doesn't, you have found your reconciliation debt; fund the acceptance path, not more generation. And encode one standard into the tools this quarter — tokens, lint, an agent config — because every convention that lives in tooling is a review that never has to happen.

When everyone can create, creation stops being the metric — the team that ships fastest is the one that accepts fastest.