The Product
Mosif
It builds a design system out of what a client has already made, then keeps checking that the system still matches reality.
Agencies inherit brands far more often than they get to create them. A client turns up with a live site, a Figma file and a folder of assets, and buried somewhere in all of that is a design system nobody ever wrote down.
Mosif reads what's actually there and builds one: colour and type tokens, a component inventory, the practical layer you need before you can design or build anything.
The part I care about more is what happens after that. Mosif isn't a document you export once and forget about. It's a versioned system that other tools can read from, and it keeps checking itself against the client's live product as things change.
The wrong blue
The idea came from a story about a print job that went to press in the wrong blue. The brand guidelines given to the printer had the wrong colour values in them, and nobody downstream had any reason to doubt it. It wasn't carelessness. The document was just wrong.
The other version of this problem is slower. A guideline is accurate the week someone writes it and gradually stops being accurate after that. There's a redesign, a few new landing pages, a handful of developers making sensible decisions on their own, and eventually the document and the product are describing two different brands. The product is the one clients actually see.
What you get
Design tokens
Colour, type and spacing as real variables you can export as JSON or CSS, rather than values described in a paragraph.
Component inventory
Buttons, cards, inputs, navigation and their variants, detected from the client's actual product rather than assumed.
The rest of the system
Iconography, elevation, radius scale, motion, grid and breakpoints, imagery direction, usage patterns and accessibility standards.
A Figma library, optionally
The components built directly inside the agency's own Figma file, so the system arrives as something you can use rather than something you have to recreate.
Identity
Dark is the default rather than a mode you switch into, because the product is something people sit in front of for a while. The chartreuse only ever means confirmed or healthy, and it gets used sparingly so it still registers when it appears.
Ink
#101827
Near-black navy. The ground everything sits on.
Canvas
#F5F1E8
Warm paper. Light mode, and the calmer settings screens.
Interface
#D8D2C7
Soft stone. Borders, dividers, quiet structure.
Signal
#C8F450
Electric chartreuse. Confirmed and healthy states only.
Accent
#4263EB
Cobalt. Primary actions, links, anything active.
Alert
A terracotta rust for flagged drift. Not pinned down yet.
Why it's different
Most tools in this space work forwards. You give them a name or a mood and they generate a brand for you, which means they're inventing one. The few that do start from an existing site tend to skim it, and what comes back is thin.
Mosif goes the other way. It starts from what the client has already shipped and works backwards to the system underneath it.
There's a second difference that matters more to me. Most tools hand you a deliverable and that's the end of it. Mosif is built to sit in the middle as something other tools plug into. AI design and coding tools are increasingly built to read a structured design system rather than parse a written document, so having one that's machine-readable and actually current is turning into useful infrastructure.
How it works
- 01
Connect
You point it at the client's live site. It works from what the brand has already put out in public, so there's nothing for you to prepare and nothing to go back to the client for.
- 02
Analyse
It goes through the site properly rather than skimming it, working out which patterns are doing real structural work and which are one-offs.
- 03
Propose
What it finds comes back as a proposed system: a set of tokens and a component inventory, offered as suggestions rather than decisions.
- 04
Confirm
You go through it, correct what's wrong and approve the rest. Nothing lands in the system until someone has actually signed it off.
- 05
Version
Whatever you confirm becomes a version. It's stored centrally, and anything that needs to read the system reads that.
Watchers
A design system is only accurate until the next deploy. Watchers are agents that keep an eye on the client's live site, Figma file and codebase, and tell you when something has drifted away from the system you confirmed.
You can scope them. If you only care about colour and logo usage and don't want to hear about spacing, you can say so, and that configuration stays visible and editable rather than sitting inside a black box.
Live site
Checks the live product on a schedule and tells you, by email or Slack, when something no longer matches what you confirmed.
Figma
Notices new styles and components appearing in the design file, so drift gets caught while it's still a design decision.
Code
Flags off-system styling before it ships, at the point where it's still cheap to change.
Coverage
Mosif works through everything the site publicly exposes, which is a much bigger surface than it sounds and a lot more than anyone is going to get through by hand.
What it won't do is tell you it found every last thing. Anything sitting behind a login, or reachable only by some very particular route, is out of reach by definition. So nothing comes back marked as final. You see what was found, you decide what's right, and the system records what you confirmed rather than what a machine assumed.
After that it stays current. Products keep changing, and the system keeps up with them.
Principles
AI proposes, you decide
Every step is something you curate rather than something you're handed. Mosif does the tedious part, narrowing thousands of raw values down to a shortlist worth looking at, and a person makes the actual call. That split isn't a safeguard added at the end, it's the shape of the whole product.
It won't invent a brand's purpose or values
Mosif can't read intent off a website, so it doesn't pretend to. Anything in that territory is either clearly marked as a suggestion or taken directly from the person who actually knows. It never gets presented as something the system worked out for itself.
It won't tell you CMYK values are correct
A screen has no idea how something is going to print. Where print values show up, the assumption gets flagged and someone still has to check it on press. A system that admits what it can't know is worth more than one that sounds sure of itself and puts a job through in the wrong blue.
Who it's for
Mosif is aimed at agencies doing web, product and digital design work. They're the ones who inherit a client's brand and have to reconstruct it before they can build anything, and they're also the ones with Figma files and codebases worth watching. Most of them are running several client projects at once, which is why it's built around a workspace with projects inside it rather than a single account.
There's a knock-on effect I like. Ongoing design governance is a service agencies have struggled to sell, mostly because it was difficult to actually deliver. Mosif turns it into something they can offer as a retainer under their own name.
Where it's going
Right now I'm building the core of it: the analysis and the confirmation flow. After that, the live-site watcher, then the Figma library.
Then getting it in front of a small group of agencies and finding out what I've got wrong.
Founder partners
I'm looking for a handful of agencies to help shape Mosif by using it on real client work. Different sizes, different kinds of clients, and direct input into what gets built. If you spend your time reverse-engineering other people's brands, I'd like to talk to you.