Three years inside one product

Show the work while it runs, then put it away. Your question, then a plan, then a live row for each step, then the answer. Once the answer lands, the steps retire behind a chip. A long conversation that keeps all its working on screen turns into a log file.

Twenty calls are one step you expand. An agent's work is a tree. Shown flat, one lookup that fanned out to twenty calls buries the rest of the investigation. Nested rows, with depth drawn in a fixed gutter, keep every title lined up however deep it goes.

Every claim points back to the step that produced it. Citations in the answer are chips that open the exact piece of work behind a sentence. Sources say where information came from; citations say how the assistant used it. Two different questions, two different controls.

Assume they'll leave. The launcher counts work in progress, and when an answer lands while the chat is closed, it turns green and says so. One chat panel lives on every page, so asking about something never costs you the page you were looking at.

A memory you can audit. The assistant remembers things about your systems and habits, and one wrong guess quietly shapes every answer after it. So every row is readable, editable, pinnable and deletable, and says where it came from: you told it, it inferred it, or the system set it. Correct an inferred fact and it stops being re-guessed.

One node anatomy for several hundred action types. Commands, cloud calls, chat messages, tickets, AI steps, loops, branches, approvals. Each node has the same parts in the same places (status, inputs, hover actions), so the canvas reads the same whatever is on it. Most of the consistency came from reviewing the build, pull request by pull request.

Four ways in, not one. Start from a blank canvas, a template, pasted code, or describe what you want to the assistant. A single on-ramp is what kills adoption of a builder.

Branches fan out instead of colliding. Conditional paths used to overlap and their handles were too small to hit. Now true, false and switch paths each have their own visual language, and they spread out rather than stack.

Rehearse before it's live. Dry-run the whole thing, run up to one step, or simulate a trigger, all before anything fires for real. After a run, a panel answers the first question everyone has: what set this off?

Explain the AI steps. People wouldn't place an AI step they couldn't predict. Each one now says what it does with its input and what it gives back. The cheapest possible fix for "I don't trust this one".

Three layers, and the middle one matters most. Primitives at the bottom, recipes for the three screens the product is mostly made of (a listing, a modal, a form) at the top, and in between, written decision rules. A rule got added the first time each "which one?" question came up: status pill or chip, toast or banner or field hint.

Same look, different meaning, still two components. A form select and a toolbar filter look identical, but an empty form field might be an error, while an empty filter just means "showing everything". So they're separate components, and picking between them is a UX call, not a code call.

Colour goes on the change, never on the number. In this product, a drop from 1.2 cores to 0.5 is a win, while the same drop in availability is an incident. Comparison components take a direction and pick the colour themselves, and a percentage never shows without what it's a percentage of.

The visible result is things disappearing. About 25 one-off components collapsed into primitives: two cards into one, three dialogs into one modal, a scatter of custom pills into one status label and one chip. Then I co-led moving about 110 files onto the system with three engineers, and every "which one here?" question became a new rule.

Written for people and for AI. AI agents now write a real share of the interface. They follow stated rules well and guess unstated ones badly, so the system is a written spec that's loaded into every coding session. It's the new version of "check the Figma".

Four tabs are four questions, in order. What is this, what caused it, what's the evidence, and what do I do. One scroll, sticky tabs, and the context of the alert stays put on the left.

The verdict comes first. The conclusion used to sit below the evidence that produced it. Now a summary card leads, and each of its points jumps to the evidence behind it. Actions moved into one bar, so acting isn't a scavenger hunt.

~69 kinds of evidence, and no empty boxes. Metrics, logs, dependencies, capacity, recent deploys, code. Each needs its own card a person can scan, and the rule is that a card with nothing useful in it never renders. Otherwise the screen is a wall of empty sections exactly when it matters most.

"Done" isn't "fixed". A command that finished hasn't necessarily fixed anything. So results say outcome unverified, unknown or needs checking when that's the truth, and a fix that keeps recurring says so plainly.

Brief me, don't count at me. Triage used to open on four counts: how many events came in. "1,110 events" doesn't tell anyone whether today is normal. The top now says what was handled, what repeated and what still needs a person.

Read the real state. The Setup Center checks what's actually connected, covers every provider, and holds the rest of the product back until something works.

Name panels for what you get. The old list followed our own integration categories, which asked people to care about our taxonomy before they had any reason to. Every panel is now named for the outcome.

Nobody leaves setup. Long provider lists shrink to a few tiles and one dropdown, never a link out to the full integrations catalogue. The earlier design sent people there with a banner to come back. The trip was the problem, not the banner.

No skip, but you can stop the nagging. A skip button lets people mark things done that aren't. Instead, you can dismiss a reminder without touching the item's state, so the checklist stays honest. And only required items count toward progress, so an optional extra can never drag the bar backwards.

Changed our minds, twice. How empty a new account has to be before the product locks to setup was reversed twice after watching real teams use it. The mechanism was easy. The judgement wasn't.