Practice · How we work

The AI practice behind the work

Every studio says it uses AI. Far fewer can tell you when they decide not to. This is the adoption framework our practice runs on — written for an enterprise design team, adopted there, and the reason our AI claims come with a decision rule attached.

Why a framework at all

Because “we use AI” is not a method. It is a sentence that can mean a careful hybrid workflow or someone pasting a prompt into a tool and shipping whatever comes out.

This framework was written for an enterprise design team facing a specific, unglamorous problem: requirements arriving late, designers hand-building wireframes from scratch, repeated feedback loops with subject-matter experts, and defects surfacing in user acceptance testing after development had already written the code. Every one of those is expensive, and none of them is a tooling problem on its own.

The answer was not “add AI.” It was deciding which stages of the process AI genuinely compresses, which it does not, and — the part most people skip — who decides which path a given piece of work takes, and when.

A framework that cannot tell you when to switch it off is a sales pitch with a flowchart on it.
3 years
staged adoption, not a single rollout
2 paths
standard and time-pressed, with a named decision owner
5 stages
of the process where AI was found to genuinely help
Adopted
by the enterprise it was written for

The decision rule

The centre of the whole framework, and the part that makes the rest defensible. Two paths. Somebody owns the call. It gets made at a known moment rather than drifting.

Standard path

Planned work with full discovery time. AI assists the wireframe baseline, then the designer refines it to higher fidelity against the requirements, and it goes through analyst and engineering review before anything is committed.

Default. Most work should be here.

Time-pressed path

Fixed deadline, compressed discovery. Fast throwaway comps to settle a direction, then agent-generated prototypes built from the governed component library so output stays pattern-compliant — and a move back to full refinement once the direction is confirmed.

Exception. Earned, not assumed.
Decision owner: the UX lead, confirmed at sprint planning. Not the designer mid-task, not the engineer under pressure, and not whoever is most tired on a Thursday. A named owner at a known moment is what stops the exception quietly becoming the default.

Where it actually helps

Five stages, each with a specific tool and a specific reason. The point is the narrowness — these are the places it was found to pay, which implies everywhere else it did not.

Stage 01

Baseline wireframes

The first draft, not the final one.

  • What changes. Requirements go in, a structural baseline comes out in minutes rather than the better part of a day, and the designer starts from something to argue with instead of an empty frame.
  • What does not. The refinement, the hierarchy decisions, and the judgment about what the screen is actually for. The baseline is a starting point; treating it as an output is how teams ship plausible-looking nonsense.
Stage 02

Rapid prototypes from the design system

Fast, and still pattern-compliant.

  • The constraint that makes it work. Agents build from an established component library and approved patterns rather than generating free-hand interface. Output stays on-brand and consistent with production, so prototypes are usable at handoff instead of being a picture of an idea.
  • The precondition. A governed design system has to exist first. Without one this stage produces technical debt at speed.
Stage 03

Concepts and direction

Throwaway on purpose.

  • What it is for. Quick clickable comps that explore several directions in minutes, so a team can settle on one before anybody invests in building it properly.
  • The rule attached. Approved concepts move into the design system and get rebuilt. They are a conversation, not a deliverable.
Stage 04

Competitive and gap analysis

The most underrated stage of the five.

  • What it produces. Market and competitor research with cited sources, capability comparisons against your own requirements, and a synthesis of where the gaps and opportunities actually are — in hours rather than weeks.
  • What it decides. Not just the product vision. The sequence — what ships first and why. Sequencing argued from analysis rather than from whoever asked loudest is a design decision, and this is where it gets made.
  • Closing the loop. Findings get reviewed against current requirements, and the requirements get updated where the evidence supports it. Analysis that does not change a document was decoration.
Stage 05

Testing before development

Where the money actually is.

  • The problem it targets. Defects found during user acceptance testing mean code has already been written, reviewed and merged. Fixing them is rework at the most expensive point in the cycle.
  • The change. Clickable prototypes tested remotely with real users before engineering starts, with task success rates and timings captured rather than impressions. Design defects surface pre-development instead of post-build.

Staged over three years, deliberately

Adoption fails when it is attempted all at once. Each year builds on a capability the previous year established, and each one moves UX earlier in the process.

Year one — augmented

AI-assisted wireframing, prototype testing before development, and AI-supported requirement review. UX still enters the process late, but produces better work faster. This year buys credibility and the data to argue for the next one.

Same position in the process, better output.

Year two — discovery

UX moves upstream. AI-generated journey maps, workflow diagrams and task flows let design participate in requirements rather than receive them, and an AI-assisted design system reduces inconsistency and design debt across active projects.

Earlier in the process, shaping the brief.

Year three — predictive

Product analytics feed back in. Behaviour, click patterns and workflow inefficiencies get analysed continuously, so design moves from reacting to reported problems to identifying them before they are reported.

Reactive becomes predictive.

The business case

A framework that cannot be argued in hours and rework will not survive its first budget review. This one was built to be.

The model is simple and auditable. Take your current baseline feature cycle and break it into its parts — requirements, design, development, and rework after testing. Measure the design stage before and after. Multiply the per-project saving by projects per year. Then do the same for rework avoided by testing prototypes before engineering starts.

Where the savings concentrate. Not in the design stage, which is the part everyone focuses on. In the rework: defects caught before a line of code is written cost a fraction of the same defect caught in user acceptance testing. The design speedup is the visible win; the rework reduction is the larger one.

We will run the numbers against your baseline, not ours. The figures that matter are yours — your cycle length, your project count, your rework rate. A model built on somebody else’s inputs is a brochure.

UXAI adoptionDesign system governanceProcess designPre-development testingCompetitive analysisRelease sequencing
Design stage
hours per project, measured before and after
Rework
weeks avoided by testing before development starts
Cycle time
end-to-end delivery, the number leadership actually tracks
Consistency
design debt, measured against the component library

What this means for you

Two ways this shows up, depending on what you need.

If you hire us

to design or build

This is the process running underneath the work. It is why the AI claims on this site come with limits attached, and why you can ask at any point which path a piece of work is on and get a straight answer.

If you have a team

and no framework

We will write you one. Current-state assessment, a staged adoption plan your leadership can fund, the decision rules that keep it honest, and the measurement model to prove it worked. Built around your tools and your constraints.

If you already

started and it stalled

Usually one of three things: no design system for the tooling to build against, no decision owner so the fast path became the only path, or no baseline measured at the start so nobody can prove it helped. We can tell you which.