So it writes code that looks like everyone else's. Kata is a command-line tool that reads your codebase once, teaches your AI tools what your product actually looks like, and comments on your pull requests when something drifts away from it.
Free and open source. Nothing leaves your machine.
Those are our real voice rules running on that text. Edit it and watch them work.
Installs into
The problem
Not badly. Just identically. A model that has never seen your product reaches for the average of everything it was trained on, and the average has a look. You know it the moment you see it, because you are the one who rewrites it afterwards. The same drift runs through the copy and the code, and you rewrite those too.
A four-point star on anything intelligent. It has become the universal badge for "a machine made this".
// the badge nobody's brand includes
Three traffic-light dots around a demo that is not in a browser. Nobody asked for a window and there isn't one.
// it is not a window
Typed, not drawn. They break at every size, sit differently on every platform, and belong to no brand.
// your icon set has none of these
Indigo into violet, on the badge and the button and the hero. A default that four hundred thousand landing pages share.
// #6366f1 → #8b5cf6, the people's gradient
Lines filled greedily until one word is stranded. It reads as careless because it is.
// "love", alone on line two
A hex code typed inline because the model did not know you had a variable for it. Your system quietly rots.
color: #c1492d; /* --shu exists for this */// correct colour, orphaned value
A dash in every sentence and claims shaped like "not just X". Readers recognize the cadence before they finish the paragraph.
"It isn't just fast — it's a whole new way to build."
// two tells, one sentence. try it in the checker above
PascalCase pages in a kebab-case app. A hand-rolled fetch when your framework ships one. Correct, compiling, and visibly not yours.
inertia('OrderHistory') // yours are kebab-case// runs fine. still wrong here
What you get
Kata is not advice and it is not a style guide you have to maintain. It produces files you can read, and it wires them into Alchemy, the same one-file QA setup that already runs your tests and lint.
One
A single file describing how your product actually looks. Colour named for the job it does, your layout rules, which component is for which purpose, and the things you never do.
// .kata/app.kata.json "accent": "#D4652E", "rule": "Buttons change colour on hover, never move.", "neverUse": ["emoji icons"]
Two
The same file rendered into whatever each tool reads, plus an MCP server for long sessions. You write the language once rather than maintaining four copies that slowly disagree.
$ npx kata connect ✓ CLAUDE.md ✓ .cursorrules ✓ AGENTS.md ✓ MCP server registered
Three
Teaching a tool is one time. Drift is forever. Kata reads each pull request against the same file and says what moved, in your language rather than generic lint rules. Alchemy runs the check like it runs your tests, so every pipeline it generates already enforces taste.
$ npx kata review // alchemy runs this in CI PR #482 · 3 findings ✗ Hardcoded #FEFEFC → use var(--card) ✗ Chip used for a list → use wordmarkRow
The difference
Both panels answer "add a pricing card". The only variable is whether the tool had a Kata file loaded. The card on the right is built from the same one that renders this page, so the thing it matches is the page you are reading.
Kata review · 5 findings
check and arrow-up.#6366f1. No token matches. Your accent is --shu.Kata review · clean
The obvious question
You probably do, and it probably is not the part that helps here. Tokens are the solved problem. Every tool on earth exports colour. The part an AI actually needs is the part nobody writes down.
How it works · one
Nobody writes a design system from a blank file. Yours is already in production, spread across a stylesheet, a component folder and somebody's memory. Kata reads it out.
This is the one step that needs a model. Kata calls whichever one you already pay for, reading a key from your environment and never storing it. Anthropic, OpenAI, Google, or a local model through an OpenAI-compatible endpoint.
Everything after this is cheaper. Generating rules files is a pure transform with no model at all, and most review checks are deterministic. There is no account to create and no upload step, because the compiler is a CLI that runs where your code already lives. A design language in progress is one of the few things a company genuinely cannot post to a stranger's server.
How it works · two
Rules files are the same content in four dialects. Writing them by hand is how they drift apart. Kata renders them, so they cannot.
How it works · three
ESLint knows your code style and Prettier knows your formatting. Neither has any idea that your buttons are pills or that your headlines break at the sentence. Kata reads each pull request against your file and says what moved.
Select a finding to see the rule it came from.
How it runs · Powered by Alchemy
Kata compiles your language. Alchemy enforces it. The rules live in alchemy.yml, the one QA file your tests and lint already share, and they run wherever Alchemy runs: every commit, every pull request, every pipeline it generates. There is no new config file in your repo root. And outside PHP, kata runs standalone: same rules, your own CI.
# alchemy.yml
kata:
voice:
paths: ["blog/**", "*.html"]
deny:
- pattern: "\u2014"
max: 2
reason: "dash cadence reads machine-made"
code:
deny:
- pattern: "inertia\\('[A-Z]"
reason: "pages are kebab-case here"
The part nobody else does
A compiler that quietly guesses is worse than one that admits a gap, because a guess in token shape survives review. Open questions ship into the rules file, so the model asks instead of inventing.
The registry
A compiled language is a file, so it can be published, read and installed the way a package can. Open one to see the whole system, then take it with one command.
A commercial product's system, where colour is named for the job it does rather than its hue. Tokens, components, an icon set, a voice, and a product promise that no surface sends without a person.
A PHP framework's system, read out of the code that renders the landing page. It started as a scrape of the live site and closed eleven of its fifteen questions once a person answered them.
A React framework's system, dark only, with no light theme anywhere. The compile found its text hierarchy inverted, where the secondary colour is brighter than the primary one.
Built with
This site, the compiler dashboard and the review UI are all one Hanabira app. If it feels quick, that is the point of showing you rather than telling you.
Hanabira is a React framework for people who wanted Next.js to be smaller. File-based routing, server rendering and data loading, without the parts you were never going to use. If you have been looking at TanStack Start and wishing it were lighter, it is worth ten minutes.
Open source
Kata is part of the Leaf ecosystem, which has been open source since the first commit. The compiler is yours, forever, for anything, and it runs on your machine rather than ours. The team review service is the part that keeps the lights on.
Kata is being built in the open and is not finished. The compiler ships first, then the review. Leave an address and you will hear from us when there is something real to run.
You're on the list. We'll write when there's something real to run.
No product yet. No spam either. KATA by Leaf.