Every early branding engagement at R&D Creative Agency started the same way. A client brief arrives -- freeform, often sparse, occasionally contradictory. Then comes several days of moodboarding, palette exploration, type pairing, and spacing decisions, most of which happen inside the designer's head. When a client pushes back and asks why a particular colour was chosen, or why the type feels the way it does, the answer is almost always intuition dressed up as explanation.
That is not a bad process. Intuition built on experience is real and valuable. But it is slow, hard to document, and nearly impossible to hand off. I built Atelier to fix that -- not by replacing the designer's judgment, but by giving it a rigorous, reasoned starting point.
The Problem
The bottleneck in early-stage branding work is not creativity. It is the mechanical, time-consuming groundwork that has to happen before the interesting decisions can be made: classifying what kind of brand this is, establishing a colour range that holds up to contrast requirements, validating that a type pairing actually works at the sizes it will be used. These are questions with defensible answers, but arriving at those answers the manual way takes days.
The second problem is documentation. When a designer completes an early branding pass, the reasoning behind the decisions rarely gets written down. It exists as a mental model that disappears the moment the project moves to the next phase. Clients cannot interrogate it. Junior team members cannot learn from it. And when a client comes back six months later asking why their brand feels the way it does, there is often no paper trail.
Atelier was built to solve both problems at once: compress the groundwork, and externalise the reasoning.
The Position That Shaped Everything
The first instinct when building an AI branding tool is to make it generative -- give it a brief, get a brand back. I deliberately moved away from that. The goal was never to hand design decisions to a machine. The goal was to give the designer a structured, defensible starting point that they could agree with, challenge, or redirect.
That distinction shaped every technical decision that followed. Atelier proposes, it does not prescribe. The reasoning is the product, not the output. A colour palette with no rationale is just a palette. A colour palette with a written explanation of why these specific tones suit this specific brief, validated against WCAG contrast requirements and palette harmony principles, is a tool the designer can actually use.
Accessibility and human readability were built in as first-class criteria from the start, not bolted on as a checklist. When Atelier proposes a type pairing, it reasons through line height, reading measure, and minimum body size for the intended context -- not just whether the fonts look good together.
How It Works
Atelier runs in two phases.
Phase 1 generates a brand system from a brief. A freeform text input is first passed through a scikit-learn classifier trained on a labelled dataset of brand briefs mapped to six design archetypes: editorial, warm-minimal, bold-expressive, corporate-clean, luxury-refined, and playful-energetic. Each archetype carries not just visual characteristics but layout density and reading measure implications, so the classifier output carries spatial intent, not just aesthetic mood. Critically, the classifier returns a probability distribution across all six categories, not a hard label. That uncertainty is passed directly to Claude as context, so the reasoning layer knows when a brief is ambiguous and can account for it.
Claude then proposes four elements: a five-colour palette with hex values and rationale, a typography pairing with readability reasoning, a spacing scale with density and rhythm rationale, and a layout rhythm proposal covering hierarchy signal and margin proportions. Claude reasons against constraints rather than generating freely. Where a proposal involves a trade-off -- a colour that is less accessible but more on-brand, for example -- Claude names it explicitly and surfaces the call for the designer to make.
Before output is returned, a Python validation module runs a full audit across colour (WCAG AA and AAA thresholds, palette harmony scoring), typography (minimum body size, line height ratio, reading measure estimate, heading contrast), and spacing (scale coherence, type-to-space ratio, density consistency). Validation failures return to Claude for a single correction pass, with a note on what changed and why.
Phase 2 is an audit layer for existing designs. The designer uploads a screenshot of any website section -- a hero, a card, a content block -- and Atelier analyses what is mathematically happening in the layout. Claude Vision identifies the components and their spatial relationships. NumPy extracts colour values from key regions of the image. Then a Python measurement suite runs: spacing ratio analysis, typographic hierarchy signal, visual weight distribution, golden ratio alignment, WCAG contrast from the real image, harmony scoring, and reading measure estimation.
Claude interprets the numbers and writes a plain-language audit structured around three verdicts: what is working, what needs attention, and trade-offs to consider. It does not prescribe fixes. It surfaces findings with enough specificity that the designer can act on them directly.
The two phases are designed as a loop. Generate a system in Phase 1, implement it, then audit the implementation in Phase 2. Over time, the Phase 2 audit log builds a dataset of real R&D implementations that feeds back into the Phase 1 classifier.
Technical Decisions Worth Noting
The choice to use a probability distribution from the classifier, rather than a hard label, was deliberate. A brief for a boutique coffee brand might sit 62% in warm-minimal and 31% in luxury-refined. Collapsing that to a single label would lose signal that Claude needs to reason well. Preserving the distribution means Claude can account for the tension in the brief rather than pretending it does not exist.
The validation layer running before Claude's correction pass -- rather than after -- was also intentional. Claude correcting its own output based on specific, programmatically derived failure data produces better revisions than Claude self-evaluating without structured feedback.
The decision to keep the architecture as a FastAPI backend serving a React frontend, rather than a more elaborate system, was a constraint I chose consciously. Atelier is an internal tool. It needs to be fast to run, easy to maintain, and straightforward to extend. Complexity introduced at v0.1 becomes debt that slows down Phase 2.
Tested Against Real Client Work
Atelier has been run against briefs for three R&D clients: MOOV, a dark editorial Shopify storefront; Rob Roy and Konfusion, two St. John's hospitality venues with distinct but related brand identities; and Bandu Manamperi, a contemporary performance artist whose personal site required a restrained, art-forward system. In each case, the tool's output served as a starting point that the designer then interrogated and refined rather than accepted wholesale. That is exactly the intended behaviour.
What I Learned
The most interesting problem in building Atelier was not technical. It was figuring out what the tool should not do. Every AI branding tool I looked at tried to do too much -- generate logos, write copy, produce mockups. The more a tool tries to replace the designer, the less useful it becomes to one. The constraint that made Atelier useful was the decision to make it opinionated about process rather than outcome. It handles the groundwork. The designer handles the judgment. That division is not a limitation -- it is the product.
Stack: Python, FastAPI, React, Claude API, scikit-learn, pandas, NumPy
Roadmap: Figma MCP integration (v0.3) -- push generated systems directly as Figma variables and styles
