On a pale blue-grey field, the design tool pulled apart into three stacked layers seen from an angle: at the bottom the dark editor and its empty canvas, in the middle three phone screens of an invented ferry app being designed, and on top the panels, bars and selection handles. A small red square sits in the top left corner.
SimplifyUX | Product design and implementation

SimplifyUX Designer

A desktop design tool built for an AI agent to drive while I watch and correct it. The first product in the SimplifyUX suite, the software I'm building for my own company.

July 2026 to now
Claude CodeTypeScriptElectronModel Context ProtocolChromium rendering

SimplifyUX Designer is a design tool built for an AI agent to use first, with me directing it and correcting it as it works. It is the first product in the SimplifyUX suite, the software I’m building for my own company, SimplifyUX. The suite runs my work from planning to a live website, with AI agents doing most of the building. This tool designs. Its siblings keep the notes, run the websites and hold the task board that keeps every agent on its job. The screens here are rebuilt around an invented example: a ferry timetable app called Tern. Nothing in them is a real client or a real system.

What was broken

Design tools are made for a person holding a mouse. An AI agent using one has to imitate that person. It takes a screenshot, guesses where a button is, clicks, then takes another screenshot to see what happened. It is slow, it breaks whenever the screen changes, and afterwards nobody can say exactly what the agent changed.

The bigger problem is trust. An agent that designs a screen will say it is finished. Three questions go unchecked unless someone looks at the pixels: does the screen match the request, can the text be read, and can a screen reader follow it? In most teams, accessibility is a review at the end, when fixing it costs the most.

I wanted the opposite. The agent works on the design directly. I see every change the moment it lands and can undo it with one keystroke. And ‘done’ means the tool measured it, not that the agent said so.

How I worked it out

I wrote the brief and the rules, and Claude wrote the code. The brief I gave it on 2 July 2026 opens with one sentence: ‘You are the sole engineer on this project.’ My job was the product: what it does, how it looks, what it refuses to do, and when a piece of work counts as finished. Of the 1,481 commits, 1,464 carry Claude as co-author.

Four decisions shaped everything after them:

  • One document, three equal users. The canvas, the agent and the exporters all change the same document through the same set of changes. So an agent’s edit is an ordinary edit: it shows up in the layers panel, and one undo takes it back.
  • A desktop app, not a website. On 1 August 2026 I decided that files stay on the machine they belong to. The agent runs on that machine too, so a design never travels to someone else’s server.
  • Nothing copied. On 3 August 2026 I ruled that the interface is designed from first principles and never copied from another tool. Every panel had to argue for its place.
  • A ceiling on the build. On 4 September 2026 I capped the remaining work at 36 sessions. A project with no end grows forever; this one had a finish line written down before the work started.

The centre of the tool is a loop that turns ‘done’ into a measurement:

  1. 01ChangeThe agent edits the design through the same changes a person makes, as one undo step.
  2. 02DrawThe tool renders the screen to an image, exactly as it will be exported.
  3. 03CompareThe image is scored against a reference: how alike the structure is, and how far the pixels differ.
  4. 04FixThe agent changes what still differs, and the loop goes round again.

Repeats until the score passes, so 'done' is measured rather than claimed.

Figure 1. The loop at the centre of SimplifyUX Designer.

What I designed

The editor keeps the shape designers already know: layers on the left, the canvas in the middle, the details of whatever is selected on the right. Two things in the top bar are new. A green ‘Live’ dot says an agent is connected and its edits will appear as they happen. Beside it, a meter counts the accessibility checks every layer passes, all the time, not at the end of the project.

The agent panel is a conversation, but every step of it is visible. When the agent uses a tool, the panel names the tool and shows its result, so I can read what it did instead of trusting a summary. In the example above it fills a screen with real content and checks 18 pairs of text and background colours. Then it explains why the late sailing carries a symbol and a word as well as amber: colour alone fails people who can’t tell colours apart.

The compare view is the loop made visible: the reference, the render and a map of where they differ, scored in two ways. The accessibility report names 14 checks, from text contrast to heading order, and each failure comes with a one-line fix the agent or I can apply. The colour table shows each colour in both light and dark modes with the contrast of the text placed on it. The prototype check walks every path through the screens without a person and reports dead ends and missing ways back.

Everything the agent can do, it does through 52 tools. Grouped by job, they show where the weight sits: as much effort goes into reading and checking the design as into changing it.

What changed

Version 1.0.0 shipped on 12 August 2026, six weeks after the first commit, and the tool has reached version 1.1.141 since. It runs as a desktop app on Linux, macOS and Windows, with no runtime dependencies at all. Every part is its own, down to the typesetting that breaks lines, hyphenates words and handles right-to-left text.

Measured on 13 October 2026Result
Tools an agent can call52
Named accessibility checks14
Logic tests passing3,110 of 3,110
Browser tests passing1,790 of 1,790
Commits co-written with Claude1,464 of 1,481
Runtime dependencies0

The pace is the other result. Most of the building happened in the first two months. The work since has made it steadier rather than bigger, which is what the session ceiling was for.

What I learned

Directing an AI engineer is design work. The quality of this tool came from the brief, the rules and the refusals, far more than from the model writing the code. When I wrote a rule clearly, the agent kept it across hundreds of sessions; when I left something vague, it filled the gap with a guess.

Looking still matters. Three times the build log records the same finding: the visual check caught a fault that every test had passed. One was a panel that took the keyboard away from the person typing. A test asks the question you thought of. A picture shows you the one you didn’t.

And a finish line has to be written before the work starts. The session ceiling felt arbitrary on the day I set it. It is the reason the tool is steady now instead of still growing. What comes next is planned, not open-ended. The editor gets a mobile-first redesign and a direct link to the task board, so design work is planned and checked alongside everything else.

Table of Contents