I wasn't an early adopter, but now I'm an evangelist.

Ask for a gap between two icons and you'll get one. If the token doesn't exist, Claude writes the token name anyway and tucks a fallback value behind it, and the fallback is what ships. The contractor app had three of them. var(--space-3xs, 0.25rem) points at a token my system never had, so each one rendered a 4px gap on a grid that doesn't allow 4px.

Nothing looked broken, which is what worried me. A value I didn't choose looks exactly like one I did, and it gets through review because it's wearing a token's name. Give it enough sessions and a codebase fills up with decisions nobody made.

Two Figma files hold every token in the system. One has the primitives, semantic colour and type, and the grid. The other has the component tokens. Nobody edits the token or platform files by hand. Not me, and not Claude.

Figma's Variables REST API is Enterprise-only and I'm on Pro, so Claude and I built a plugin to bridge the gap. It reads the variables, writes standard token JSON and opens a pull request right from Figma. A GitHub workflow takes it from there. It builds the web, iOS and Android files, commits them to the branch and runs the accessibility checks.

estimates-etc is built for independent contractors. Every job starts with a client, and the client's address is the job site. From there it's an estimate, change orders the client signs off on, an invoice that picks up the approved changes, and payment. It runs in production, and its PDFs are laid out to match a working contractor's real invoices.

It pins a tagged release of the system, v0.5.0 right now, never a moving branch. Buttons, fields, navigation, cards, links and status chips all read their component tokens, so they follow dark mode and get their focus rings straight from Figma. Everything at page level uses semantic tokens.

Claude starts every session with no memory of the last one. Anything I say once disappears unless it lands in a file. I keep those files at three levels. A global one covers how I work on every project. Each repo has its own for that repo's rules. And commit messages record why each change happened, right where it happened.

Once a correction applies everywhere, it goes in the global file. Prefer plain CSS. No inline styles, ever. No fixed heights. Measure a craft choice before you defend it. Every one of those started as something I'd had to say more than once.

The app shrinks a long estimate to fit the page. The limit on that was a hand-picked 0.55. The smallest text on the sheet is an 8pt table header, so an overlong estimate printed that header at 4.4pt. Fine print on a contract, and unreadable for the person signing it.

Now the limit comes from a legibility rule. Divide 6pt by the smallest size on the page and you get 0.75. Past that, the document runs onto a second page. A normal estimate still prints full size on one page. The long test document stops at 0.75 and runs three pages, and its smallest text is exactly 6pt.

Emailing an estimate failed in production, and the config check kept saying everything was fine. The problem was a fallback. When the sender address was missing, the code swapped in a default that happened to be a real address, so the check passed on the default. Claude read that pass as proof its fix had worked, when it hadn't.

Two other failures looked just like it. A stale container passed for the current release twice. And six rounds of deploy instructions said "your app service" without ever naming the project, on a host that makes up its own project names.

One token source now builds three platforms. The contractor app got to production in 60 commits since August 21, and every one is co-authored with Claude, right there in the history. The system's rules are public in its repo.

The bigger win is a way of working I can take to the next product.

Both projects are young and some of this is unfinished. I'd rather list it than pretend it's done.