Not a dev agency
We don't take generic feature tickets or bill open-ended cleanup hours.
Keel AX · B2B Studio
Design Systems Architect · Agent-Ready UI Infrastructure
We are technical product designers who architect and implement design systems in code — structured so AI coding tools like Cursor and Copilot can build your UI correctly, without your engineers fixing the output every morning.
That structured codebase layer is agent-ready UI infrastructure: typed tokens, component rules, and layout logic the AI reads when it generates interfaces. We build it in your repo.
Short version: we write the UI rulebook inside your codebase — so AI stops guessing and your team stops cleaning up.
Start here
What we are (and what we're not)
This category is new. Most buyers don't have a mental model for it yet — so here it is, plainly.
Not a UX consultancy
We don't run research programmes, journey maps, or workshop theatre.
Not software engineers
We don't replace your eng team or own your backend. We own the UI structure layer AI tools need.
Not a traditional design systems consultancy
We don't deliver Figma libraries and component stickers that AI can't read.
We are
Technical product designers and design systems architects. We define how your product's UI is structured — spacing, colours, components, layout rules — and we implement that structure in code. Then we format it so AI build-tools can consume it.
The result: agent-ready UI infrastructure inside your repo. Your AI coding tools generate interfaces that match your product — first time, more often.
Product design
Need flows and product UI — not just a design system?
Yes — when the deliverable ships in your repo. Product buyers ask this a lot, so here's the straight answer.
We design and ship
User flows, screen-level UI, and product surfaces — for SaaS, apps, and consoles. Greenfield or net-new, when the thing doesn't exist yet.
We design the flows and UI — then encode them as agent-ready infrastructure in your codebase. Your team and AI build-tools can extend it without breaking.
Via: Agent Demo Sprint · Infrastructure Sprints · scoped product UI work on request
Not UX agency mode
- No multi-month discovery programmes
- No persona workshops or research theatre
- No Figma-only handoffs your eng team has to interpret
Explainer
How this works — step by step
If your team recently adopted Cursor, Copilot, or similar — this is probably familiar.
- 1
Your team uses AI to write code
Cursor, Copilot, Google AI Studio — tools that generate and refactor code inside your repo.
- 2
The AI builds UI — and gets it wrong
Wrong spacing. Invented colours. Layouts that don't match your product. Components that don't exist in your system.
- 3
Your engineers spend days fixing it
Every sprint, senior dev time goes to cleaning up AI output instead of shipping features.
- 4
The root cause: nothing reliable to read
Your design rules live in Figma or PDFs. AI coding tools work in the repo. There's no bridge — so the AI guesses.
- 5
We build the bridge — in code
We architect and implement typed tokens, component constraints, and layout rules inside your codebase. That's agent-ready UI infrastructure. AI reads it. Output improves.
UI is where teams feel the pain first — so that's our wedge. Agent work can extend beyond interfaces (workflows, orchestration, build-agent integration). It all runs on the same structured context in the repo.
Craft
Our craft
Design system architecture: the typed structure in your codebase that defines spacing, colours, components, and how pages assemble.
Traditional design systems live in Figma and Storybook — built for human designers to look at. AI build-tools need the same rules as code and data files they can parse without guessing. We build that version — and extend into layout orchestration, build-agent integration, and agent demos when teams need the full stack.
We implement in your repo. Fixed-scope engagements. Async delivery. Files and a roadmap — not a slide deck.
Positioning
Where we fit
Keel AX sub-contracts to delivery consultancies and engineering teams. Fixed-scope sprints — not open-ended staff augmentation.
| Instead of | Keel AX |
|---|---|
| Senior engineers spending days each week fixing Copilot or Cursor output | A scored audit and prioritised fix list — then sprints that implement the rulebook in your repo |
| Design system consultancies delivering Figma libraries AI ignores | Agent-ready UI infrastructure in code — typed tokens and constraints AI actually reads |
| Generic dev agencies billing cleanup as normal project work | Specialist design systems architecture studio — UI infrastructure as the product |
| UX agencies selling workshops and research deliverables | Repo-native implementation — minimal calls, concrete files |
| Telling the team to write better prompts | Structural fixes in the codebase — prompts can't replace missing rules |
Deliverables
What you get
Concrete repo deliverables from a design systems architecture practice.
UI rules in code, not Figma
Typed token files, component slot rules, layout constraints — the files AI coding tools read.
Machine-readable taxonomies and explicit constraints agents compile against.
Audit before you sprint
A scored report showing exactly where AI will break your UI — and a prioritised fix list.
Agent-readiness scorecard, constraint gap analysis, step-by-step plan.
We implement, not just advise
Sprints ship the rulebook in your repo. Your team doesn't have to interpret a PDF.
Infrastructure sprints, MCP wiring, orchestration patterns — built in-repo.
Scope grows with the problem
Start with UI infrastructure. Extend into orchestration, integration, or agent demos when needed.
Same craft muscle — audits through to shipped agent workflows.
Buyers
Who hires us
Eng lead, product lead, delivery lead, or consultancy practice lead — not HR.
- Product leads building a new SaaS surface who need flows, UI, and repo-ready structure
- Delivery consultancies needing a specialist sub-contractor for agent-ready UI sprints
- Eng leads whose teams adopted Cursor/Copilot and now lose sprint time to AI cleanup
- Platform teams building complex UIs that AI must assemble correctly every time
- Founders who need one agent-powered feature shipped before hiring a full team
Problem → Fix
Why AI keeps breaking your UI
Your design system lives in Figma. Your AI coding tool lives in the repo. Nothing connects them.
The fix is design system architecture — implemented as machine-readable rules in code, not visual docs.
| The break | The fix | Plain English |
|---|---|---|
| AI has no reliable UI rules to read in the repo | Agent-ready UI infrastructure — typed tokens, slot rules, layout constraints in code | AI invents layouts and styles because Figma files aren't in the codebase. |
| Manual refactor after every AI run | Deterministic structure — React + Tailwind environments agents compile against | Your team spends days fixing what the AI broke overnight. |
| Design files and coding tools don't connect | Build-agent integration — Cursor, AI Studio, MCP, repo rules | Two separate worlds — design intent never reaches the AI. |
Services
Services
Each offer ships concrete work in your repo. Start with the audit if you're not sure where you stand.
Infrastructure Sprints
Agent-ready UI infrastructure live in your repo (2–4 weeks)
We build the typed tokens, component rules, and layout logic AI follows.
Machine-readable tokens, component constraints, Cursor / AI Studio guardrails.
For: Team adopting AI coding tools — needs the rulebook built
Layout Orchestration
Page-assembly rules AI executes consistently
Rules for page structure so AI builds the same way every time.
Multi-tenant template logic, grid systems, orchestration consoles.
For: Platform teams with complex, multi-tenant, or console UIs
Build-Agent Integration
AI coding tools wired into your codebase with guardrails
Cursor/Copilot connected to your repo safely — not freehand in a chat window.
MCP layers, prompt contracts, repo-native agent workflows.
For: Teams whose AI tools break prod or ignore repo conventions
Agent Demo Sprint
Flow design + UI + one working agent workflow — polished and deployed — in 2 weeks
We design the user flow and UI, then ship it — so you test the idea before hiring a full team.
End-to-end: flow design, UI, orchestration, agent-ready structure, deployment.
For: Founders or product leads validating a new feature or product surface
Lead offer · Start here
14-Day Async AX Audit
Scored report + prioritised fix list committed to your repo
We read your codebase, score where AI will break your UI, and hand you the fix list.
Token/logic audit, agent constraint gaps, step-by-step implementation plan.
Fixed scope. Zero meeting theatre. For: Eng lead / CTO — AI cleanup is eating sprint capacity
- → UI structure audit
Where your styling and component rules will confuse AI tools
- → Agent-readiness score
How prepared your repo is for AI to build UI reliably
- → Prioritised fix list
Step-by-step — your team executes, or we do on a follow-up sprint
- → Async delivery
Written report in your repo. Calls only when needed.
Glossary
Jargon, translated
This space is new — most people don't have words for it yet. Start here if anything above was unclear.
- Design Systems Architect
- Someone who defines and implements how a product's UI is structured — in code, not just in design files. That's us.
- Agent-ready UI infrastructure
- The typed rules in your codebase — tokens, components, layout logic — that AI coding tools read when they generate interfaces.
- Technical product designer
- A product designer who implements in code. Not wireframes-only. Not a software engineer — but technical enough to ship structure in the repo.
- Build-agent / AI coding tool
- AI that writes code in your repo — Cursor, Copilot, Google AI Studio, similar.
- Token taxonomy
- Your product's spacing, colours, and type — as typed data files in the repo, not Figma swatches.
- Layout orchestration
- Rules for how pages and components assemble — so AI builds consistently.
- Async audit
- We work from your codebase; you get a written report. Minimal calls.
People
The studio
Jennifer Hull
Founder · Principal
Design Systems Architect · Agent-Ready UI Infrastructure
I lead Keel AX — design systems architecture and agent-ready UI infrastructure for teams whose AI build-tools keep breaking interfaces. Sub-contract to delivery consultancies and engineering orgs. GMT+2, aligned with UK/EU hours.
Jessica Hull
AX Associate
Technical Product Designer
Jess implements alongside me on audits and sprints — hands-on delivery for the studio.
React 19 · Next.js · Tailwind v4 · Cursor · Google AI Studio