audit tooling
I turned design handoffs from a trust fall into a checklist.
Forge reads a design handoff, grades it against our system, and hands back the fix. It's the front door to spec-driven development, where surfaces get built against specs and quality gates, not loose prompts.
- Design System Lead & Sole Forge Maintainer
- React, Vite, FastAPI, Shield (@ch/ui), Claude Design
- Design systems, Tooling, Internal products
- Accessibility, Fidelity, Developer experience
The frustration
Every handoff was a trust fall.
We design in Claude Design against a Shield-synced library, then build with the Shield package. Between the two, things diverge: Claude Design recreates our components as monolithic JSX files, not the composable primitives Shield actually ships. Nobody could see how far a handoff had drifted from the system, let alone turn it into something a swarm could read.
The handoff needed to know how the components mapped to each other.
Our Claude Design exports weren't just pictures. Every element carried a data-design-symbol, a label naming what it was meant to be. If the handoff already declared its own intent, I could match it against the real Shield catalog and grade fidelity automatically. That one attribute became the seed for Forge.
Sign in, then drop a handoff.
Forge sits behind Okta SSO, open to staff only. Once you're in, an audit starts with a single drop: a Claude Design export or a design-sync zip, triaged against @ch/ui.
Reuse, rework, or build new.
Forge renders the handoff live and grades every component against Shield.
The layer
Design fidelity, enforced as a spec.
Forge is the design-side front door to our SDD layer. A forged surface doesn't stay a picture: it lands as a runnable @ch/ui prototype plus a design.yaml whose mapping table is the machine-readable contract. From there the layer takes over: design-sync checks the mappings, the swarm builds into a domain-scoped feature directory, and visual-fidelity verifies the build actually composes what the design promised. Shield is the linchpin: one vocabulary at every stage, one registry every gate validates against, so design and build can't disagree about what "correct" means.
The loop
Every audit closes the loop.
An audit isn't a dead end. Its fix prompt goes back to Claude, its state is shared with the team, and it files tickets and opens PRs, feeding the next pass.
Fix prompts
An audit that only lists problems creates work. Forge generates a fix prompt, a structured brief with reviewer notes and the specific guideline violations, that you hand straight back to Claude to bring the screen in line.
Closing the loop
Audits are living, shared documents: anyone can edit, and an avatar shows who touched one last. A finished audit opens a branch and PR straight from Forge, and Linear integration means it doesn't just describe the work, it starts it. From handoff to ticket to code, one flow.
What I took away
Forge started as my own frustration and became a full-stack product I shipped and maintained alone: frontend, backend, database, security. The insight (design handoffs are inspectable) took an afternoon; making it trustworthy (booting real exports, failing closed, dogfooding end to end) took the rest. That's the part that decides whether a tool gets used or gets bookmarked.
I also came away convinced that the best design-systems work happens between the tools, not inside any one of them. Forge lives in the seam between Claude Design and Shield, and its whole value is making that seam visible. Being able to build in that gap myself, instead of writing a spec and hoping, changed what kinds of problems I could take on.