Manifesto

A team of design agents, not a prompt box

The first wave of AI design tools made one promise: type a sentence, get a screen. It worked, in the narrow way a vending machine works. You put in a prompt, a layout falls out. But anyone who has shipped a real product knows the screen was never the hard part. The hard part is deciding what the screen should be, and then being honest about whether it is any good.

That is the bet behind GlideDesign. The next leap in design tools is not a faster single-shot generator. It is a coordinated team of specialized roles that works a brief the way a real design team would — one that argues, reviews, and hands off. Here is what that actually means.

Why one model generating a screen hits a ceiling

A single model asked to “design a landing page” has to do everything at once: infer the audience, pick a visual direction, write the copy, lay out the sections, and judge its own work — all in one breath, with no chance to step back. So it does the safest possible version of each. The result is competent and forgettable. The same gradient, the same three feature cards, the same hero. Not because the model is weak, but because no one on a real team makes every decision simultaneously and never reviews it.

Real design work is sequential and adversarial. Someone frames the problem. Someone sets the visual language. Someone draws the screens. And then — this is the part the prompt box skips entirely — someone else looks at the result with fresh, critical eyes and says what is wrong with it. The quality lives in that handoff between roles, not in any single act of generation.

The roles, and what each one actually does

When you describe a product in GlideDesign, the brief moves through a sequence of specialized roles. Each one has a job, produces a real artifact, and hands its work to the next. This is not a metaphor layered over a single prompt — it is the order the work runs in.

• Strategist. Reads the brief and names the things a prompt usually leaves implicit: who this is for, what it has to prove, the core flow, and the UX risks worth worrying about. The output is a point of view, not a layout.
• Flow. Maps the screens and the path through them. What comes first, what a person has to understand before they act, where the goal sits.
• Design system. Sets the visual language — palette, typography, spacing, motion — so the screens share a logic instead of being decorated one at a time.
• UI. Composes the high-fidelity, responsive sections against that system, with real copy rather than placeholder text.
• Critic Council. Reviews every screen from six independent design perspectives and returns the issues worth fixing — with a one-click fix attached. More on this below, because it is the whole point.
• Build Engineer. Writes the implementation notes a developer — or an AI coding tool — can build from, so the design does not die in a screenshot.

Inside Studio, four of these roles have names you will watch work: Iris frames the strategy and the flow, Atlas sets the system and composes the screens, Quill writes the copy throughout, and Specs runs the review and writes the handoff. You do not have to take the “team” claim on faith. You can watch the brief move from one to the next.

The Critic Council is the part nobody else is building

Most AI design tools generate output and stop. They never look at what they rendered. A working designer would open the screen, scan it, and notice that the headline is fighting the subhead for weight, that the call to action is too quiet, that the spacing rhythm breaks halfway down. The tool that only writes layout sees none of that, because seeing it is a separate job.

So GlideDesign makes it a separate job. Every screen is reviewed by a Critic Council from six distinct perspectives, each one a discipline a senior reviewer would bring to a critique:

• Usability — can a person actually accomplish the goal without friction or confusion?
• Affordance — do the interactive parts look interactive, and do they signal what they do?
• Restraint — is anything decorative earning its place, or is the screen busy for the sake of looking busy?
• Visual identity — does this feel like a specific product with a point of view, or a template with a name pasted in?
• Legibility — does the type create a real hierarchy, with enough contrast and rhythm to read comfortably?
• Iconography — do the symbols clarify meaning, or are they ornament filling space?

These are perspectives defined by method, not by celebrity. We are not channeling a famous designer or claiming anyone's endorsement. Each lens is a checklist of questions a careful reviewer asks, applied consistently to every screen. When a lens finds something, it does not just complain — it returns the issue with a specific, one-click fix you can accept or ignore.

This is also where we get to be honest with you. AI design output is not flawless, and a tool that pretends otherwise is lying. The Critic Council is how the team catches its own weak spots in the open instead of shipping them quietly. A reviewed first direction with its problems flagged is worth more than a polished-looking screen that nobody checked.

Want to see the review step in practice? Start a brief in GlideDesign and watch a screen come back with its issues named and a fix attached to each one.

Why a team beats a bigger prompt

It would be easier to cram all of this into one enormous instruction and ask a single model to behave. We tried versions of that. It does not hold. Separation of concerns is not a software nicety here — it is what lets each role do its job without the others crowding it out. A strategist that is also worrying about palette makes worse strategy. A reviewer that wrote the screen cannot see the screen.

Splitting the work into roles buys three things. The decisions become legible — you can see why the design is the way it is, because the reasoning happened in named steps. The review becomes genuine — a critic that did not author the work is free to call it weak. And the output becomes steerable: when you disagree, you can correct one role's decision instead of rewriting a single monolithic prompt and praying.

Watching it work, not trusting a black box

“Agentic” has become a crowded word, often a coat of paint over a single model doing one thing fast. Our answer is not louder claims but visibility. You can watch the brief move through the roles in real time — the strategy taking shape, the system being set, the screens composing, the critique coming back. The point of a team is not autonomy for its own sake. It is that you can see the work being done, and step in where your knowledge of the product beats any inference.

This is early, and we will say so plainly. The team does not replace your judgment; it gives your judgment somewhere useful to land. What you get is a strong first direction, reviewed from six perspectives, with implementation notes to build from — not a finished product handed down from a black box.

Where this is going

We think the prompt box was a useful first chapter and a poor destination. A sentence in, a screen out, no one reviewing it — that ceiling is real, and you feel it the moment you try to ship what comes out. The work that matters in design is the deciding and the critiquing, and those are exactly the parts a single generation skips. Giving each of them a dedicated role, and putting the critique at the center, is how the output starts to feel like it came from a team that cared.

That is the workspace we are building — the design-first one we wanted as builders ourselves.