Skip to content
HOZU1.0.0-rc.2
Menu

Your AI writes the app. Hozu checks it.

Describe the app you want. Your AI builds it, and Hozu checks every change so nothing breaks behind your back.

↓ Press AI CHANGE: you only asked for a green button. Watch what else the AI changed, and what Hozu says.

You: “Make Checkout green”
Oak stool × 1$640

Free shipping on orders over $1,000

Checkout

✔ types ok · 0 errors · lock current

Peg, the red peg that checks, waving
A tenon joint: two posts, a beam with two tenons and two red pegs

Watch · 2 min

Two minutes. No code.

You dream it, your AI builds it, and Peg, the red peg that locks the joint, checks every change before it reaches anyone. For vibe coders and designers.

English captions · voice generated by elevenlabs.io

The bill

Your AI has never seen Hozu. It costs about what Nuxt does once it knows it.

Every model already knows Nuxt. Hozu it learns from our guide, in every session. Even so, a change costs 1.32–1.42× Nuxt’s tokens, and once the guide is known, 1.02–1.06×: about the same. What is left is learning, not the framework.

What it buys: over 29 changes, Hozu passed every check of every step. Nuxt silently broke a working export in 3 of 29 changes while its typecheck and build stayed green. Your agent runs the checker and fixes what it finds before it says “done”.

These are trial 0024’s numbers: Hozu 0.14 against Nuxt 4.5.2, one app, one model (Claude Opus). Later versions have not been measured this way. Earlier versions cost more: 2.64–2.73× on Hozu 0.7, 1.34–1.72× on 0.8.

Speed

Checked, and still the lightest page.

The same page, 100 products and a cart counter, built with each framework and run in its own production server. Every request is rendered fresh. Only the parts that react to clicks ship JavaScript.

One page, four frameworks, rendered per request

Hozu 0.25.0

adapter-node

Requests/s
15,818
JS (gzip)
9.7 KB
Interactive
60 ms

SvelteKit 3.0.0

Svelte 5.57.1, adapter-node 6.0.0

Requests/s
6,581
JS (gzip)
33.0 KB
Interactive
101 ms

Nuxt 4.5.2

Vue 3.5.43, Nitro 2.13.4

Requests/s
2,953
JS (gzip)
75.8 KB
Interactive
91 ms

Next.js 16.3.8

React 19.3.0, App Router

Requests/s
1,616
JS (gzip)
130.9 KB
Interactive
164 ms

Measured on 2026-10-08 with Hozu 0.25.0: one run on an Apple M4 Pro, Node 22.22.2, Chrome 154; browser timings with the CPU slowed four times. Next.js serving the page prerendered reaches 6,664 requests per second. With gzip accepted, Hozu answers 11,454 and Next.js 1,502; Nuxt and SvelteKit send their pages uncompressed. JavaScript sizes are all gzipped the same way. How we measured · The libraries alone (React, Vue, Preact, Svelte)

How you work

Three steps. Your agent does the typing.

  1. 1 · Create

    One command makes the app and puts the Hozu guide next to it.

  2. 2 · Ask your agent

    “Add sharing to my notes.” Or point at the screen with Hozu DevTools: it hands your agent the file and line.

  3. 3 · It checks itself

    It runs hozu check and fixes what it finds before it tells you it is done.

bash
npm create hozu@latest my-app -- --agent claude
cd my-app
npm install
npx hozu add feature tasks --page /tasks
npx hozu check

Hozu UI

Official components your AI can change.

Buttons, forms, tables and dialogs, in two themes. Start with npm create hozu@next (the 1.0 candidate) and say yes when it asks: they are in your app as plain files you and your agent can edit.

  1. Yours to edit

    The kit is copied into ui/. Updates replace only the files you did not change.

  2. Checked by Hozu

    Colours come from named roles, and an override of a component is said out loud, so a change stays consistent.

  3. Placed with DevTools

    Drag a component onto your page, write what it is for, and hand the request to your agent.

Checked by the agent

Your agent checks its own work. In a real browser.

hozu check reads the whole program before anything runs. Then hozu browse uses the page the way a person would, in Chrome, and reports what each step changed. Your agent runs both before it tells you it is done, and you can run them too.

  1. hozu check

    Types, every rule with its suggested fix, a contract for every decision, and the lock of what each part does.

  2. hozu browse

    Fill, click, submit and move between pages, with JavaScript on, off or both, as two different visitors at once.

  3. hold, then release

    Keep a save waiting and read the busy page. Each step reports reloads, flashes and layout shift.

A storefront card in one trial looked right, and its link still could not be clicked: the heading’s ::after lay on top of it. Since 0.25, hozu browse fails that click and names what is on top. What 0.25 changed

Who may see it

Your notes stay yours. Hozu checks.

Every query and change over a visitor’s data says who may run it. Forget to say it, and the app does not type-check. Hozu refuses everyone else before your code runs, and checks that a list holds only the visitor’s own rows.

  1. access: 'signedIn'

    Or the row’s owner, or a condition such as an admin role. One line next to the query.

  2. Forbidden

    Anyone else gets a refusal, and the page answers 403 or sends them to sign in.

  3. Try it as someone else

    One hozu browse command signs in as two visitors and opens the first one’s page as the second.

Data

Your API, called from where it belongs.

Each query and mutation says what it needs, and Hozu decides where it runs. A public API is rendered on the server first, then called straight from the browser: no second hop, no double traffic. A token that lives in the browser never travels to your server, and an app without a server exports to GitHub Pages.

  1. runs: 'server'

    A database, a secret or the session. The resolver in app.ts, as before.

  2. runs: 'either'

    A public API, or your own with CORS. In the HTML on first paint, then from the browser.

  3. runs: 'browser'

    The visitor's own token. Loading state on the server, the API call in the browser.

Backend

Your backend can be Go.

A resolver is ordinary backend code behind a typed declaration, so it does not have to be TypeScript. Name the effects in remote(), run hozu gen, and implement the Go interface it writes. Who may call, caching, tags and the check of every answer against its output schema stay in the Hozu server, so a service that answers wrongly fails closed.

  1. remote()

    One entry in app.ts names the service, its secret and the effects it implements. The rest stays in TypeScript.

  2. hozu gen

    Writes the Go contract from your declarations. Change one and forget to regenerate: hozu check says which effects are stale.

  3. Tried by agents

    An agent moved a shop admin’s order lifecycle, inventory and dashboard to Go. The notes app passes its hidden browser checks with every resolver in Go.

Go pays off when a resolver does real work; for a thin one, the extra hop costs more than it saves. TypeScript stays the default.

Test as you build

Run your API next to the page.

npm run dev puts an API drawer under every page: the data it reads, the changes it makes and your endpoints, with the requests each call really sent. The environment is declared once, secrets stay on the server, and the server can call your APIs on the inside.

Scale

Five hundred features. Same page.

We generated apps of 50 and 500 features and fixed what grew with the app instead of the page. A page now loads only its own code and links, the check after an edit runs the type check alongside everything else, and several servers keep one another’s caches honest.

  1. 1.9 s check

    hozu check after a one-line edit at 500 features. It was 4.6 s.

  2. Same page size

    A page carries the same data at 50 and at 500 features, and loads only its own code: 237 bytes here.

  3. Many servers

    A change on one server clears the others’ caches. Memory stays bounded.

DevTools

Point at it. Your agent gets the line.

Run npm run dev, choose Select and click what is wrong. Say what should change, try a size, a colour or other words right on the page, and hand it over.

The request names the file, the line and the Hozu way to make the change: one button or every button, a message shared by two places, a state that needs a contract. Your agent stops searching and starts fixing.

And it points back: each part it changed gets a numbered frame on your page, with a note in your words.

For designers

Feels like Figma.

DevTools uses the keys, the measuring and the words a designer already has: Shift+Enter goes up a level, Alt measures, the Design panel reads like Figma’s, with your tokens first.

Assets shows every component and variant beside your page, with the screens you name in previews.ts. Drag one in or try a change on the page, then hand it to your agent. It writes the code; you never open a file.

Shift+Enter · Enter · Tab

Select around it, inside it, beside it.

Alt

Hold it and point: the distance in px.

W × H

Every selection shows its size.

Design panel

Frame, Auto layout, Layer, Fill, Stroke, Effects, Text.

Variables

Tokens first: red · #fb3a0e, 2xl · 24px.

Comments

Your agent’s notes are numbered pins: reply or resolve.

What it catches

Mistakes that look fine and still break.

Each of these type-checks and builds. Hozu stops it anyway, and says what to do. Tap, hover or tab to a card to see the real diagnostic.

✘ HZ049

Your notes, on someone else’s screen.

✘ HZ049 cached-user-data

A user-scoped query is cached across requests.

fix: freshness: 'request'

✘ HZ054

You ticked three boxes. The app saw one.

✘ HZ054 single-value-form-read

A multi-value field is read with ui.dom.form.

fix: ui.dom.formAll(name)

✘ HZ091

Your list showed someone else’s notes.

✘ HZ091 rows-outside-owner

A query with owner access returned rows the visitor does not own.

fix: read only the visitor’s rows in the resolver

✘ HZ057

Behaviour changed. Nobody reviewed it.

✘ HZ057 lock-out-of-date

The lock differs from the computed lock.

fix: hozu check --update-lock, then read each now: line

Components

Declared UI. Checked class by class.

A button is a declaration in a kit, not a helper that disappears. Pick a variant: the preview, its source and what hozu render prints all come from the same component. This site is built from the same kit.

typescript
import { ui } from '@hozu/core'
import { z } from 'zod'
import { tv } from './tv.ts'

const styles = tv({
  base: 'inline-block border-4 px-4 py-2.5 text-sm font-extrabold uppercase tracking-wide transition-colors duration-150',
  variants: {
    intent: {
      solid: 'border-ink bg-ink text-paper hover:bg-paper hover:text-ink',
      outline: 'border-ink text-ink hover:bg-ink hover:text-paper',
      light: 'border-paper bg-paper text-ink hover:bg-transparent hover:text-paper',
      lightOutline: 'border-paper text-paper hover:bg-paper hover:text-ink',
    },
  },
  defaultVariants: { intent: 'solid' },
})
export const Button = ui.component({
  tag: 'a',
  styles,
  props: z.object({ href: z.string() }),
  children: true,
  render: ({ props, children }) => ui.a({ href: props.href, 'data-button': '' }, children),
})

hozu render site.Button --variant intent=solid

{
  "html": "<a class=\"inline-block border-4 px-4 py-2.5 text-sm font-extrabold uppercase tracking-wide transition-colors duration-150 border-ink bg-ink text-paper hover:bg-paper hover:text-ink\" href=\"#\" data-button></a>",
  "class": "inline-block border-4 px-4 py-2.5 text-sm font-extrabold uppercase tracking-wide transition-colors duration-150 border-ink bg-ink text-paper hover:bg-paper hover:text-ink",
  "owned": [
    "background-color",
    "border-color",
    "border-style",
    "border-width",
    "color",
    "display",
    "font-size",
    "font-weight",
    "letter-spacing",
    "line-height",
    "padding-block",
    "padding-inline",
    "text-transform",
    "transition-duration",
    "transition-property",
    "transition-timing-function"
  ]
}

Two classes that set one property on one element are reported as HZ079, so an override never wins by accident. Read about components

The 3D joint at the top is a component too.

A Blender script builds the model, three.js renders it in a client component, and the same machine that runs the demo tells it when to split. Without JavaScript it is a still image.

typescript
import { ui } from '@hozu/core'
import { z } from 'zod'
import { tv } from './tv.ts'

const poster = ui.asset(new URL('../assets/joint-poster.webp', import.meta.url))
const model = ui.asset(new URL('../assets/joint.glb', import.meta.url))

export const Joint = ui.component({
  tag: 'div',
  styles: tv({ base: 'relative aspect-square w-full max-w-[34rem] select-none' }),
  props: z.object({ split: z.boolean() }),
  client: new URL('./joint.client.ts', import.meta.url),
  load: 'visible',
  render: () =>
    ui.div({}, [
      ui.img({
        src: poster,
        'data-model': model,
        width: 900,
        height: 900,
        alt: 'A tenon joint: two posts, a beam with two tenons and two red pegs',
        class: 'h-full w-full',
      }),
    ]),
})

// site/joint.client.ts
export default implement<typeof Joint>(({ el, props, signal }) => {
  // … GLTFLoader, toon materials, ink hulls, idle turn, drag …
  return {
    update(next) {
      const changed = next.split !== split
      split = next.split
      if (changed) pose(split, !reduce)
    },
    destroy() { … },
  }
})

Under the hood

feature() → IR → validator → compiler → runtime

Every page is planned from what its data declares: who may see it and how fresh it must be. Only nodes bound to a machine ship JavaScript; everything else on this page is plain HTML.

The trials

Measured, with the rough edges included.

Trial 0024: the same notes app built and changed 28 times, with Hozu learned from the guide, with it already known, and with Nuxt. The last eight changes were written by a session that never saw Hozu. Held out: 1.32–1.42× Nuxt’s tokens learning, 1.02–1.06× once known (two runs each).

Trial 0024: 29 steps, the same model and the same hidden checks
Hozu 0.14Nuxt 4.5.2
Changes with every check passing2926
Silent failures (build green, feature broken)03
Tokens per unseen change, against Nuxt1.32–1.42×baseline
The same, once Hozu is known1.02–1.06×baseline

Before that, trial 0021 (Hozu 0.8). Cost: 1.34–1.72× Nuxt’s tokens per change (steps 13–20, one run per framework), against 2.64–2.73× on Hozu 0.7. Outcome: 0 regressions and 0 silent failures over 16 changes, against 8 regression failures and silent failures at 5 steps on Hozu 0.7. Not met: the cost ratio still rises slightly over the run.

Trial 0021: the same notes app, changed 16 more times by an agent
Hozu 0.7Hozu 0.8
Regression failures80
Steps with silent failures50
Cost against Nuxt (geometric mean)2.64–2.73×1.34–1.72×
Trial 0021 per-step cost, lines and checks for Hozu 0.8 and Nuxt

Raw records; Nuxt step 14 is undercounted there, and the report explains the correction. Read trial 0021 · Read trial 0024 · All trials

Start

Build something. Then try to break it.