I led product design for Agents by Docker, a desktop app that let people build and run AI agents without touching a terminal. I had already designed the CLI/TUI that became cagent, so I owned the translation of its model (agents, tools, MCP servers, model providers) into a GUI a knowledge worker could use. I set the experience direction, drove the core flows from first run to a working agent, and ran the usability studies that tested whether non-developers could actually build one.
The problem
cagent proved people wanted to build their own agents, but research showed only developers were using it. Its power sat behind a YAML file and a terminal. The people this project wanted to reach use Claude or ChatGPT every day, yet never open a CLI or GitHub.
The brief was to package cagent as a desktop app for that audience. The constraints were tight:
No user data and no time to recruit. We had to design from first principles, then validate on a working build.
Requirements moved daily. PRDs and acceptance criteria changed inside the sprint.
A v0 already existed. Engineering had built a functional Electron app on MUI before design joined. It worked, but it exposed cagent’s developer concepts as-is.
The real design problem was conceptual, not visual: how do you explain tools, models and MCP servers to someone who has never configured an API key?
Key decisions
Each card is the decision, the alternative, the reason and the result.
Keep one mental model from CLI to desktop
“An agent built in the app should be the same agent the CLI runs”
Options
Carry cagent’s model into the GUI, or invent a simpler desktop-only abstraction.
What I chose
One model. I had designed cagent’s TUI, so I knew which concepts were load-bearing and which were ceremony; the app renamed or hid the ceremony and kept the structure.
Result
An agent built in the app runs in cagent unchanged, and one set of docs serves both audiences.
Lead with outcomes, not configuration
“What do you want this agent to do?”
What I saw
The v0 opened on agent settings, models and tools, the way a YAML file does.
What I chose
Reordered the experience around the outcome the person wanted, with technical choices defaulted and revealed progressively.
Result
First run to working agent stopped requiring prior knowledge of what a model provider is.
Make tools understandable before they’re powerful
“MCP servers are the hardest concept for a non-developer”
What I chose
Marketplace cards and a setup flow that explain each tool in plain language, show what it can access, and set it up in one click.
Result
Tools became a choice a knowledge worker could make, not a config file they had to trust.
Bring Gordon’s safety patterns to a new audience
“The agent acts on my machine, so I need to stay in control”
What I chose
Carried over the approval flows and danger classification I had designed for Gordon, reworded for people who don’t read commands: what will happen, what it touches, and a plain yes or no.
Result
Trust stopped being a developer-only feature.
Decide where agents live on the desktop
“An agent should feel like a helper, not another app to open”
Options
A system-tray widget that expands into the full app, versus a full-window-only approach.
What I chose
Prototyped the widget to test the always-nearby promise against the cost of a second surface to design and maintain.
Result
The exploration sharpened what the app itself had to get right; the full window carried the product.
Validate on the real build, not in Figma
“No users, no time, and a product that has to work”
What I chose
With no user base and no recruiting runway, I tested a working internal pre-alpha instead of clickable prototypes.
Result
It traded polish for truth: participants hit real models, real tools and real errors, and the findings were about the product, not the mockups.
How it unfolded
Joined a working v0. Electron on MUI, functional but developer-shaped. Audited it against the non-developer audience.
Swapped the foundation once. Chad Bercea’s RFC to move from MUI to shadcn/ui gave us a faster base; the stack swap took about 24 hours. That freed the sprints for product questions instead of component debates, and the Figma library and token pipeline plugged straight into the build.
Built the core flows. First run, onboarding, MCP marketplace and agent creation, iterated daily with engineering while requirements moved under us.
Tested what shipped. Usability studies on the pre-alpha build with both developers and non-technical participants.
Team demo, September 4, 2025. Onboarding, agent configuration and deployment, shown end to end on the real app.
Research and validation
We ran the studies on the working pre-alpha with developers and non-technical participants, because the open question was exactly the one no prototype could answer: whether someone who has never opened a terminal can build something that runs. The sessions on the real build told us where non-developers stalled, which defaults were doing too much explaining, and which CLI concepts survived translation and which did not.
Outcomes
~24 hoursMUI → shadcn/ui swap, before design sprints started
2,000 stars / 5 dayscagent’s GitHub traction at public launch
Sep 4, 2025end-to-end team demo on the real build
Product. The app carried cagent’s model to an audience that never opens a terminal, demoed end to end internally on a real, working build.
Ecosystem. cagent, whose CLI/TUI I designed, passed 2,000 GitHub stars within five days of its public launch. Agents by Docker extended that reach beyond the people who could use it.
Team. The design-engineering loop held while requirements changed daily: engineers built from the shared Figma library and token pipeline rather than waiting on specs.
The project ran under wraps at the time; demo and pre-alpha screens stay private. Details shared in conversation.
Reflection
Designing the desktop app taught me as much about cagent as about the app. Every concept that needed a paragraph of explanation in the GUI was a concept that was too loud in the CLI, and a few of them were mine. Testing on the real build instead of prototypes traded polish for truth: we learned late in absolute terms and early relative to launch, which is the only ordering that survives a skunkworks timeline.