The short version
- Role
- Staff UX Designer in Google Core AI. I designed and built the whole system: agent roles, the confirmation gate, storage, side panel and setup flow.
- Problem
- Designers could hand AI one task at a time, but not a project. Every prompt started from zero, and nothing stopped an agent from shipping work nobody had checked.
- What I built
- A six-agent crew with one orchestrator and a confirmation gate, a side panel for running agents in parallel, and a catalog of 43 skills designers can adopt one at a time.
- Outcome
- Every write waits for a human yes. A quick audit runs in about 30 seconds on 91.5% fewer tokens than a full one, and the skills ship as standalone pieces anyone can drop in.
Portfolio-safe version. Product and model names are generic, no colleagues are named, and every visual on this page is redrawn, not a screenshot.
- PrototyperPrototypes, visual QA, Figma, motion and decksDesign
- AuditorHeuristic reviews, AI prompt evaluations, accessibilityResearch
- LibrarianLocal lookups, project wikis, privacy check before sharingKnowledge
- Ticket opsFriday ticket scan, drafts for you to approveTickets
- Team lead1:1 prep, team time off, quarterly rollups (managers only)People
AI could do tasks. It couldn't run a project.
The agent IDE gave designers a capable model in a chat box. That's useful for one task at a time: write this copy, check this screen. Real design work is a project, though. It's a prototype, a review, a ticket update and a 1:1, all moving at once. Each new prompt started from zero, and nothing stood between an agent and work going out before anyone had looked at it.
I wanted the opposite of autopilot. One designer should be able to run a small studio's worth of parallel work, and still be the one who decides what ships.
Every request runs the same loop
Each step belongs to a different agent, so nothing gets skipped. The last step always belongs to a person.
- PlanMimir
Reads your docs, agrees scope in one click, writes the brief.
- CheckAuditor
Audits screens and journeys, writes the requirements.
- BuildPrototyper
Builds the prototype and checks it in a real browser.
- Clean upLibrarian
Removes personal data and broken assets.
- Your OKYou
One click to approve, or send it back.
- ShipThen, and only then
Nothing leaves your machine without that click.
Heuristics and visual craft for early mocks. 91.5% fewer tokens than a full run.
Designers get accessibility and component checks, researchers get prompt reviews, writers get copy review.
All 31 review skills, a privacy lint and a project wiki entry.
Two front doors, one memory, zero baseline context
Heavy work runs in the agent IDE on a cloud workstation. Quick questions go through team chat, on your phone. Both share one memory, so a task can start in one and finish in the other.
Only a small core loads on every turn. Skills and data stay on disk until a request calls for them, which keeps more than 130,000 tokens of context deferred until they're needed.
The agent IDE
- Builds prototypes and decks
- Searches code, docs and bugs
- Runs several agents in parallel
Chat, on your phone
- Short answers in seconds
- Calendar and bug lookups
- Approves ticket drafts on the go
Identity, routing and safety rules.
Hand-offs and drafts between the IDE and chat.
Each skill loads only when a task needs it.
Research records and design rules, scrubbed of personal data.
Run parallel agents without hunting through ten tabs
Parallel agents create a new problem: which one is waiting on you? The side panel docks inside the IDE and answers that first, then shows machine health and how much model quota is left.
- Lanes first, because attention is the bottleneckNeeds you, Working, Idle. The only thing that pulses is the lane waiting on a person.
- Expand a card, continue in one tapSee an agent's goal, status and latest message, then reply or pop out to the full chat without leaving the panel.
- Auto-fallbackWhen a model runs out of quota, the turn moves to one with headroom instead of failing.
- Built on shared workThe panel runs on a teammate's conversation-tracking engine. Its visual language was inspired by an open-source LCARS project.
A soft pulse only when an agent pauses for your answer.
Radar rings speed up as the auth cert nears expiry.
The waveform reads all cores and speeds up only under real load.
A two-wave tank shows memory fill at a glance.
43 skills you can adopt one at a time
A personal system only matters if other people can pick it up. I packaged everything into one hub, the Bag of Holding: the full crew and side panel up top, then a searchable catalog of standalone skills underneath, so a designer can start with one capability instead of installing everything.
Setup takes about two minutes: paste one prompt, answer seven one-click questions about role, team and tone, and optionally dock the side panel. Presets switch on the right agents for UX design, research, writing, marketing and managers.
- ai-governors
- heuristic-audit-hub
- accessibility
- design-system-manager
- functional-scoper
- ux-brd-writer
- journey-mapping
- visual-qa-remediation
- cognitive-load-conversion
- ux-storyboard
Four calls that shaped the system
The call: the gate comes first.
Tradeoff: every write waits for a click, which is slower than letting agents publish on their own.
Result: people trust it with real work, because nothing ships, sends or changes without them.
The call: zero baseline context.
Tradeoff: more design work up front to split the system into a small core and on-demand pieces.
Result: about 2.8 KB loads per turn, more than 130,000 tokens stay deferred, and a quick audit costs 91.5% less than a full one.
The call: personality is optional.
Tradeoff: maintaining two personas, a Star Trek crew and a plain "Executive" voice.
Result: the theme makes it memorable, and nobody who finds it silly has to put up with it to get the skills.
The call: motion only when state changes.
Tradeoff: no decorative animation, even in a deliberately playful UI.
Result: when something moves in the side panel, it means something, and it all holds still under reduced motion.
Designing the brakes before the engine
The interesting design problem in agentic AI isn't what the agent can do. It's where the person stays in the loop, and how to make that feel fast instead of bureaucratic. I spent more time on the confirmation gate and the "Needs you" lane than on any single agent, because that's where trust is won or lost. It's the same lesson as every design system I've built: the tool is the easy part. Adoption is the work.
Specialists do the work. An orchestrator routes it. Nothing ships without an explicit yes.