Capture a sparse design intent. Decompose it fractally into atomic components. Review under five specialist lenses — UX, accessibility, brand, performance, business. Hand off to implementation as typed artifacts the app factory can build from. Design that survives review.
Convert a five-sentence description into a structured design intent: the user, the problem, the success criteria, the constraints. The intent is a typed artifact — searchable, citable, versionable. Subsequent design work references it; subsequent decisions inherit from it.
A design is broken recursively into atomic components. Each component knows its purpose, its constraints, and its relationships to siblings. Decomposition stops at the level a single component can be implemented unambiguously. The result is a tree the system can build from.
Each component is reviewed under multiple specialist lenses in parallel — user experience, accessibility, brand alignment, performance budget, business viability. Disagreements surface. Critiques are merged deterministically into prioritized actions. The author iterates against structured feedback.
The traditional answer is a designer who specializes in one of these and apologizes about the others. The wireframe gets reviewed three times for three different concerns; each review introduces new constraints; the design oscillates.
Meridian's Muse layer reviews under all five lenses simultaneously. The accessibility specialist checks contrast, focus order, and ARIA. The brand specialist checks token compliance and voice. The performance specialist projects bundle and frame budgets. The UX specialist evaluates flow and affordance. The business specialist asks whether this design serves the funnel. Their critiques are merged into a single ranked action list. You iterate once, against everything.
The decomposition is the hard part. Doing it badly produces a flat list of widgets that never coheres. Doing it well takes a senior designer two days of careful structural work.
Meridian decomposes fractally. The intent becomes domains. Domains become surfaces. Surfaces become components. Components become atomic primitives. At every level, the children inherit constraints from the parent and adapt them to local context. Decomposition stops where ambiguity stops. The result is not a flat list — it is a tree the implementation can walk.
The traditional handoff is a Figma file, a Slack thread, and a chain of "what about edge case X" questions. Half the design's nuance evaporates between specifying it and shipping it.
Meridian's design output is a typed artifact the app factory consumes directly. Components carry their constraints, their accessibility annotations, their performance budgets, and their behavior specs as machine-readable properties. The factory builds from the design, validates against the constraints, and ships. The design that ships is the design that was reviewed.
Most AI design tools produce inspiration. A pretty mockup, a moodboard, a generated image. The artifact is a starting point — a designer still has to spec it, a developer still has to build it, and the connection between the inspiration and the production code is loose.
Meridian's design output is a structured tree of typed components, each with its constraints, each reviewed by a swarm of specialists, each ready to hand to the app factory for implementation. Designs cross-link to the documents that informed them, the user research that motivated them, the business goals they serve, and the implementation skills that build them. A design is not a picture — it is a node in the same knowledge graph that runs the rest of your business.
"You came for a design tool. By the time you go to production, you'll discover the same substrate decomposes your specs, manufactures your components, links your design intent to your shipped code, and audits the change history."
Seven other domains running on the same substrate
Get a private walkthrough when Creative & Design opens to early customers.