Organisational Reality

Approved in Theory

Every design systems architect knows the cycle. Exec approval. Zero implementation. The gap between the boardroom and the sprint board is where design systems go to die — and it has nothing to do with technology.

The Pattern

This cycle. Every. Single. Time.

I've lived this at least four times across different organisations. It follows the same arc so precisely you could set a calendar reminder for when the deferral is coming.

It isn't bad luck. It isn't bad stakeholders. It's a structural pattern baked into how delivery-oriented organisations function.

The Vision

Approved.

You present the NorthStar. Execs are energised. The room is electric.

The Architecture

Approved. Next quarter.

You propose the token system. "Brilliant. We'll prioritise that next quarter."

The Prototype

Approved. Not scheduled.

You build the NorthStar. Engineers are impressed. "But we need to focus on the backlog."

The Component Library

Approved. Indefinitely deferred.

You design the system. "Looks fantastic. The devs are just a bit buried right now."

Next Quarter

Approved. Again.

New priorities. New backlog. Same cycle.

∎ end of cycle
The Real Blocker

It's not technical

I spent years assuming the resistance was technical. Legacy code. Complex architecture. Migration risk. And yes, all of those were real — but none of them were the actual blocker.

The actual blockers looked like this:

The myth

Angular is the blocker

The reality

A team that knows Angular is the blocker

The myth

Complexity is the blocker

The reality

A sprint board that rewards feature delivery, not infrastructure, is the blocker

The myth

Feasibility is the blocker

The reality

A culture that measures velocity, not vision, is the blocker

The myth

The legacy codebase is the blocker

The reality

The legacy org structure is the blocker

The team iterates. It never innovates. They're building faster versions of the wrong thing.
The delivery trap, lived experience
The Delivery Trap

A productive team that never transforms

Backend-developer-led teams optimise for what they can measure: tickets closed, features shipped, velocity maintained. It's rational behaviour inside a broken incentive structure.

Discovery work — prototyping, token architecture, design system foundations — doesn't fit in a sprint. There's no ticket for “create the future.” No velocity metric for “make the next five years faster.” So it gets deferred. Then deferred again. Then it becomes part of the mythical “next quarter” that never arrives.

I've watched Angular-to-React migrations get approved, then delayed, then deprioritised for three consecutive years. Not because React wasn't better. Because migrating doesn't close a feature ticket. The engineers who maintain Angular are productive. The engineers who would migrate it are a risk. The sprint board can't see what it's losing — only what it would cost.

This is the delivery trap. The team is working. They're shipping. Every metric looks fine. And the organisation is slowly calcifying around a codebase that the market left behind.

Fantasy Island

The innovation lab that never comes home

Organisations know they have this problem. Their solution? Create an innovation sub-company. A “lab.” A “digital incubator.” A team of bright minds in a separate office with beanbags and whiteboards, freed from the sprint board to think big.

It doesn't work. These teams are siloed from day one. They build beautiful prototypes that live on Fantasy Island — disconnected from the delivery codebase, the production constraints, the real users, and the actual tech stack. The lab produces vision. The delivery team produces features. They never meet. The lab gets defunded after two years when nobody can point to production impact.

The problem isn't that innovation and delivery can't coexist. It's that organisations separate them into different buildings, different teams, different budgets — and then wonder why the innovation never lands.

Design systems are the bridge that Fantasy Island never had.

Start with tokens in delivery — small, non-disruptive, embedded in the existing codebase. The delivery team doesn't even need to change how they work. Tokens are just variables. Then build NorthStar prototypes in discovery— using those same tokens, that same design system. The prototype isn't a fantasy because it's built on the same foundation as production. The innovation and the delivery share DNA from the start.

No separate lab. No separate budget. No Fantasy Island. Just a design system that serves both directions — giving delivery consistency and giving discovery a launchpad that's already connected to the real world.

The Quiet Part

Why CTOs quietly kill what they publicly approve

Here is the thing nobody says in the design systems community, because it makes us sound cynical: agentic design systems are politically dangerous.

A system that lets one person do the work of five isn't just efficient — it threatens headcount, budget, and organisational power. A CTO with 40 engineers and a £4M annual budget has power proportional to that team. A design system that compresses the need to 10 engineers and £1M isn't a technical upgrade. It's a political threat. The CTO will approve it in the boardroom and quietly ensure it never gets prioritised in the sprint.

This isn't cynicism. It's organisational behaviour. Quinn and Cameron's Competing Values Framework calls it Hierarchy culture — an organisation type that values control, stability, and the protection of existing structure above external adaptation. Hierarchy cultures don't reject innovation. They absorb it into committees and working groups until it becomes harmless.

The people who approve innovation are rarely the people who implement it. And the people who implement it are directly measured by the velocity that innovation would disrupt.

The innovation dies not from opposition. It dies from infinite, polite deferral.

The innovation doesn't die from opposition. It dies from infinite, polite deferral.
Organisational behaviour, not cynicism
The Agentic Answer

Stop asking for permission. Start delivering proof.

Agentic design systems don't need a migration. They don't need the delivery team to stop what they're doing. They work alongside the existing codebase, from the inside out.

CLAUDE.md doesn't require a rewrite — it reads what's there and builds within it. A design token file doesn't replace the Angular components — it sits alongside them and makes the next thing built in React consistent from day one. You don't start with the migration. You start with one context file, one token, one component. The system grows from the inside while the delivery team keeps shipping.

The political answer is the same: stop asking for a migration. Start delivering outcomes that make the Angular codebase look obsolete by comparison. Build the NorthStar prototype in React that shows what the product could be. Let the output make the argument. The prototype argues better than any proposal deck ever could.

This is what the Stakeholder Simulator is built for. Not just to practice pitching — but to identify exactly which stakeholder is the actual political blocker, and what evidence they need to see before they'll unblock it. A CTO who fears headcount loss needs a different argument than a CTO who fears migration risk.

The delivery trap assumes that the team controls what gets built. Agentic design systems sidestep that assumption entirely. One architect with the right context files and a well-scoped agent can demonstrate in a week what a committee would defer for a year.

The INC Frame

What gets approved is I. What gets killed is <N>.

The I<N>C framework makes the failure point precise. Executives approve the Ideate phase — the vision, the NorthStar prototype, the possibility space. They love it because it costs nothing yet and threatens nothing yet.

The <N> layer — Narrate — is where the organisation gets built. Token architecture. Component contracts. CLAUDE.md context files. Shared naming conventions. This is the infrastructure layer that makes C (Create) scale. And this is exactly what never gets prioritised, because it produces no visible output on the sprint board and has no immediate feature delivery attached.

The delivery team ships features (partial C, without the N foundation). The design system architect builds the N. The N never gets resourced. So the next round of features ships on a shaky foundation again. And the cycle restarts.

Agentic design systems are a direct answer to this. The N layer doesn't need a sprint ticket. A single CLAUDE.md file, a token JSON, a structured component API — I can build the N while the delivery team ships their C. It doesn't wait for permission. It just starts being true.

The organisation approved the vision. I'm building the infrastructure. By the time they notice, the system is already working.

Is your design system approved in theory?

If you've been through this cycle — the boardroom approval, the sprint deferral, the polite indefinite postponement — I'd like to talk. Not about what went wrong, but about how to build from the inside without waiting for the organisation to catch up.

/