One view for
human+agent product teams.
Synclair gives your product one browsable surface — design system, components, knowledge, codebase map, and AI setup, live from the repo. Humans get visibility. Agents get context. Both stay aligned because they're reading the same place.
Humans and AI build in the same repo —
but no one can see the shape of it.
You can't see which skills and agents are in play, and AI-written code quietly drifts from your system's rules of composability. There's no shared picture of what humans or agents are actually doing — so the two fall out of alignment. Synclair draws that shape: one surface where the whole repo's structure, work, and rules are visible to both.
Four steps from repo
to a living project surface.
Add Synclair to your repo
One clone drops a synclair/ folder into your repository — versioned in git, right beside your code. Nothing about your app changes.
Diggers discover and map your view, backend, docs and AI setup
Intake agents read your code, tokens, PRDs, and Figma, then map it all — components cataloged, tokens traced, briefs distilled. It starts full, not blank.
Your repo gets its own dashboard and registry for humans + agents
The whole project becomes one browsable surface. People explore it, agents load it — the same place, always current.
Stewards keep what you build in sync with Synclair’s view
As you build, steward agents keep the library, docs, and tokens healthy, and git keeps the surface aligned with your code — every commit, both ways.
A team of nerds
that work for your repo.
Specialist agents seed the hub from what you already have, then keep it healthy as you build. Four crews, each with a job.
One surface,
everything the project knows.
Design tokens — color, type, spacing — as one semantic vocabulary, lint-enforced.
Components, blocks, and templates in three tiers — each with a live preview and derived API.
PRDs, specs, and Figma linked to their source and distilled for agents. Link, don't copy.
The project's research memory — prior art, competitive notes, and decisions with rationale.
The backend at a glance — areas, API surface, data model, jobs, and integrations.
Every route with a live preview and the components each screen is built from.
Dated build reports with ranked, trackable recommendations — every count cross-checked against live data.
An advisory sweep of where code steps outside its own foundation. It flags, never touches.
The running stack, plus an opt-in check for whether your foundation has drifted behind upstream.
Recent commits and diffs read straight from git. The activity feed is just git, rendered.
Every skill, agent, and MCP server the project fields — categorized, one click from its source.
One command palette across components, tokens, docs, and pages.
Storybook renders your components.
Synclair documents your whole system.
Storybook is a component workshop — a dev dependency you import to render components in isolation. Synclair treats a component as a documented entity, so it catalogs things it can't execute, and it covers everything a component gallery leaves out: tokens, knowledge, the system map, the AI setup — for humans and agents alike.
They can coexist. For the narrow job of “see my components rendered in a gallery,” Storybook is the more focused, mature tool — Synclair can even embed a Storybook story as an item's picture. It's the other four-fifths — knowledge, maps, governance, agent context — where they diverge.
A catalog you can trust,
because it checks itself.
Documentation rots the moment it drifts from the code. So every rule Synclair can machine-check ships with its check — the same gate runs on your machine and in CI, and a wrong catalog is treated as worse than a smaller one.
Facts are computed
Props, usage counts, and coverage are read live from the real source — so they can't drift, because nobody transcribes them. Anything authored is pinned to a commit hash.
Rules aren't advisory
Raw hex and magic px are lint errors, not review nits. Registry, render coverage, and doc depth are checked — and the same checks run in CI on every push.
Steward agents review
A render-auditor loads every gallery card to prove it actually draws — no blank frames or code placeholders. Reports cross-check every number against live data before they publish.
A cheerful freeloader
that mooches off tools you already have.
No platform to log into, no servers to babysit. Synclair lives in your repo, piggybacks on git and GitHub to stay in sync, and lets your AI agent do the heavy lifting. It brings the context; everything else, it borrows. Engineless, on purpose.
It's a repo app
Plain files committed inside your project. Nothing to deploy, no database to run — the repo is the app.
Git & GitHub keep it in sync
No server, no accounts. Every change is a commit; sync is just pull and push. GitHub is the backbone the whole hub rides on.
Your agent is the engine
Synclair brings the context, not the compute. Bring your own AI agent — it reads the hub and does the work. Engineless, in the best way.
Every fact lives once in git and projects two ways — a page a person browses and a machine-readable form an agent loads. No server, no accounts; sync is pull/push.
Yours to take anywhere.
It's plain files in your repo. No lock-in, no platform to log into — fork it, host it, or read it straight from the folder.
One choice: one repo or two.
New project or existing app, the only fork is topology. Then you seed the hub — fresh for a new brand, or from your real code for an existing one.
Inside your product repo
The hub, skills, and guardrails travel with your code, so every agent gets them ambiently. Start a new project in the clone, or co-locate it into an existing repo.
Beside your product
A separate companion that documents your app one-way — nothing lands in your repo. No dependency, no build step, zero cost to the host team.