The Mothership:↳ Built for Flow
A Senior Product Designer’s Design Ops system: encode the design system so agents stop drifting, then ship under real constraints. Site, tokens, and architecture compiled through a human-steered AI loop — also a cognitive prosthetic for a neurodivergent brain. You are reading the output.
Back to Work// 01
Overview
I didn't plan to build an app. I was deep inside a brutal enterprise migration – 48 tenant sites, 3,500 legacy pages, zero ramp-up – and kept hitting the same execution blocks: AI tools that drift the moment they lose context, and no infrastructure built for how my brain actually works.
So I built an agentic system designed to route around both.
Mothership is an orchestration console that encodes your design system into machine-readable instructions, giving AI agents a stable source of truth – without hallucinating, drifting, or ignoring your tokens. The entire stack – this site, the token system, the architecture – was autonomously orchestrated and compiled through an AI developer loop. It's also a set of digital prosthetics for a neurodivergent brain. Built around my cognitive wiring, not against it.
The clearest proof it works: you are inside the compiled output right now.
// 02
Challenge
There were two problems running in parallel, and I couldn't solve one without the other.
The External Problem
AI coding tools are powerful but system-blind. They don't understand your tokens, your naming conventions, or why a component is being used a certain way.
Every session starts from zero. Every handoff requires re-explaining the entire design system. And when you're working at scale – multiple templates, multiple tenants, multiple stakeholders – that drift compounds into debt, fast.
The Internal Problem
I'm AuDHD, recently diagnosed, and recovering from burnout. The tools that exist – long linear chat threads, context-heavy onboarding, rigid daily workflows, walls of undifferentiated text – are almost precisely engineered to drain a neurodivergent brain.
I needed infrastructure that externalised my working memory, chunked complexity into single decisions, and protected deep focus rather than constantly interrupting it.
Neither problem had an off-the-shelf solution. Mothership had to be both things at once: a technically sound orchestration engine, and a cognitive environment I could actually operate in.
// 03
Process
The idea came from friction. I was brought into a large enterprise migration as the systems thinker on the project, and arrived with an architectural approach the team wasn't structured to receive.
While navigating that gap, between the solution I could see clearly and the environment I was operating in, I realised I needed to build the infrastructure for myself. Not for that project. For the way I work.
I started in Cursor, learning by doing. The early build was messy. I hit what I now call the Frankenstein problem – code that no longer reflected my intent, sessions that drifted, components that conflicted with each other.
The natural response would have been to keep patching. Instead, I stopped, stepped back, and executed a clean architectural reset.
That reset produced the Triple-Anchor system:
A visual system architecture page in Figma – the bird's-eye view
A PROJECT_ANCHOR.md in Cursor – the single daily source of truth
A clean GitHub repository with strict commit discipline – the safety net
From there I developed a Hub-and-Spoke workflow: short, single-focus build sessions anchored to a persistent MOTHERSHIP_STATE.md document, specifically designed to prevent the same context drift I was solving for in the product from happening inside my own process. I was using the methodology to build the methodology.
The concept kept growing. What started as a design library module evolved into something with a larger architecture: a modular orchestration engine where the design system was just the first pillar. The scope wasn't wrong – it was scaling. That realisation forced me to think harder about architecture for extensibility from the start, not just immediate function.
It's a lesson I now carry into every system I build.
// 04
The Console: What It Actually Does
The most important thing to understand about Mothership is what you see when you open it.
Three panels, working in concert.
Soft Bento demo · separate visual language from this portfolio · POC
Open-source DX POC · Template Grid panel, building in public
Template Grid Manager
The Template Grid Manager on the left holds your design building blocks – nodes categorised by type (Display, Functional, Content, Navigation), each carrying its own status and token dimensions. This is the library layer.
Token Calibration Unit
The Token Calibration Unit in the centre is a live editor. Select a node and you can adjust its exact values in real time – corner radius, internal padding, surface fill, border preset. These aren't visual overrides. They feed the system.
Agentic Prompt Console
The Agentic Prompt Console on the right is where the architecture earns its name. It watches what you're doing across the other two panels and compiles a fully structured AI instruction, automatically, in real time. Node logic, visual specification codes, instruction protocol, structural constraints. All generated. All machine-readable. Ready to inject directly into Cursor or any AI coding tool.
This is the gap current tooling doesn't bridge. Design tools document the system. AI coding tools write the code. Mothership sits between them, translating design intent into agent instructions before a single line of code gets written. No drift. No re-explanation. No output that ignores your tokens.
// 05
Key Architecture Decisions
// 06
Site as Proof
Compiled Output
This live application is not documentation of the system. It is the system – site, tokens, and architecture – autonomously orchestrated and compiled via an AI developer loop.
Mothership's first fully operational output is the portfolio you're on – live on Vercel, built with Next.js and TypeScript, with a Claude API integration handling image curation for case studies.
Beyond the site, what shipped is the infrastructure: a validated token architecture, a working agentic prompt console, a template grid manager, a live token calibration unit, and a governance layer that means any AI agent, or future collaborator, can onboard to the system by reading three files.
No invented metrics. What I can say is that the system works: one designer, no engineering team, shipped a production-ready portfolio and a working orchestration console in three months of non-linear, burnout-conscious building.
jennifer@hull_architecture:~/mothership$ compile --target site [loop] propose → validate → correct → deploy [gate] AGENTS.md compliance .............. PASS [gate] tokens.json → foundations ......... PASS [gate] human-in-the-loop review .......... PASS diff --git a/deliverable b/proof --- a/documentation +++ b/compiled output - mockup of the system + site · tokens · architecture + live on Vercel · Next.js · TypeScript // You are inside the artifact. jennifer@hull_architecture:~$ status --ready-for-new-builds▋
// 07
Reflection
The concept outgrew my initial architecture, not because the architecture was wrong, but because I couldn't anticipate the full scope at the start. The lesson isn't “plan more upfront.” It's that when you're building something genuinely new, your architecture needs to be designed for scale before you know what you're scaling to. I know that now in a way no document could have taught me.
The bigger surprise was how natural this work feels. I've always been technical – I just found the traditional coding environment too tedious to sustain. Agentic tools removed the friction standing between me and something I'm apparently wired for. For someone neurodivergent, finding a way of working that matches your cognition rather than fighting it is the difference between burnout and flow.
Mothership isn't finished. It's a living system. But it's already doing what I built it to do, letting one person operate with the output of a team, by building the infrastructure that thinks alongside them.
BUILT BY ONE.
POWERED BY SYSTEMS.
THIS SITE IS THE PROOF.