Trade-offs, measured honestly
Hozu buys explicit structure and checks with authoring cost, constraints and a different ecosystem fit.
A design choice is not a universal advantage
Hozu makes application structure unusually explicit. Queries declare ownership and freshness, views are closed trees, and machine transitions have contracts. This gives the tools more of the program to inspect. It also gives an author or agent more unfamiliar material to learn, read and maintain.
The trial records measure that cost instead of assuming the design must be cheaper. They compare particular tasks, models, scaffolds and change requests. A ratio from one trial is not a prediction for every application, and a passing acceptance suite is evidence about the checked behaviour rather than proof of general correctness.
Why the comparison is with Nuxt
Every cost figure below is Hozu against Nuxt, and the choice is deliberate. Nuxt is the model's home ground: it is in every model's training data, and agents write it fluently. Hozu is not. Each session learns it from the guide. The trials keep everything else equal: the same model, the same spec and the same hidden acceptance. Only the framework differs.
So the ratio mostly measures learning. A study of the transcripts found that most of the extra tokens go to reading the guide, multiplied by every call an agent makes (ADR 0038). On the long run, 0.8 measured 1.34–1.72× Nuxt per change (trial 0021). That gap is expected to shrink as the guide gets shorter, and once models know Hozu. The correctness differences come from structure: what the framework makes hard to write. They are not expected to shrink. Trial 0024, pre-registered in ADR 0055, separated the two by running the same 29 changes with the guide cold, with it already known, and in Nuxt.
On the eight held-out changes, Hozu 0.14 as an agent meets it today cost 1.42× Nuxt's weighted tokens (1.32× in a second run). Once the guide was known, the cost was 1.06× (1.02×): about the same as Nuxt. So most of what remains is learning, and it is paid once per session. Both Hozu arms passed every check of every step; Nuxt silently broke a working export for three steps while its typecheck and build passed. The limits: one app, one model (Claude Opus), and the "known" arm is estimated by removing what the preloaded guide costs to carry. Trial 0024 has the method and every number.
The task-board results vary
Trial 0010 used two runs per arm and step for a task board. Hozu’s mean weighted-token cost was 1.64× Nuxt for the build and 1.44× for the change. Correctness stayed equal in all eight runs. The build missed the stated target, while the change met it. The report points to reading the unfamiliar framework and generated source as remaining costs.
Trial 0011 evaluated additional inspection tools and scaffold summaries. Its measured ratios were 2.28× for building and 1.53× for changing, and both targets were missed. Nuxt was not rerun for that comparison; the report uses trial 0010’s baseline. Across the four Hozu 0.3 runs, the reported comparisons were 1.96× and 1.48×. These values should not be silently mixed with a newly measured Nuxt run.
The tools were used, but some guidance was not followed and a scripted-edit mistake contributed to one build. That matters when interpreting a framework-level claim: an agent’s workflow and ordinary mistakes can move the result. Read trial 0010 and trial 0011 together rather than selecting the more flattering number.
Correctness and cost can move separately
Trial 0012 introduced an account-based notes task designed around common errors. Hozu passed 72/72 checks across its runs; Nuxt passed 67/72. The difference appeared during one change, after both frameworks had passed every build check. The reproduced Nuxt failure involved in-place mutation of shallow-ref data, which disrupted ordering and subsequent refreshes.
That result illustrates the kind of silent regression Hozu’s contracts and framework-owned data refresh aim to prevent. It does not establish a general failure rate: the trial contains only two runs per framework. Nor was the additional checking free. Hozu’s mean weighted-token comparisons were 2.79× to build and 2.06× to change. Trial 0012 explains both sides of that result.
The account scaffold changed the next build comparison. In trial 0013, two new Hozu runs used --with auth; both passed 15/15 acceptance checks and the mean build comparison became 1.66×. Nuxt was not rerun: the baseline is the earlier notes trial. There was no new change-step measurement in that follow-up, so its build improvement must not be presented as a measured improvement to changing the app.
Hozu 0.5 targeted the cause that a study of the transcripts identified: agents spend most of the extra tokens reading the guide, and every additional call carries that reading again (ADR 0038). With ordinary TypeScript in callbacks, a shorter guide split into hozu docs topics, and fewer verification detours, trial 0016 measured 1.38× Nuxt to build and 1.45× to change, with four Claude runs per step. All five runs, including one by Codex, passed all 36 checks. The Nuxt baseline is still the two runs of trial 0012, and the cost target of 1.3× was not reached: reading an unfamiliar guide remains the price. Trial 0016 records it.
Hozu 0.7 attacked what remained: the code the surface forced an agent to write (ADR 0041). Trial 0019 measured 1.14× Nuxt to build and 1.38× to change on the notes task, and 1.75× and 2.03× on a widget-heavy task (Leaflet, Chart.js, GSAP and Three.js), with two runs per step and every check passing. The extra cost is smaller, not gone.
The constraints are part of the product
A closed view tree is useful when you want the framework to inspect dependencies and event bindings. It is less convenient when a component design depends on arbitrary render functions, undeclared effects or a large existing library’s assumptions. Hozu offers typed client components for imperative DOM integration: their props, slots and emitted events (emits) are declared, but the client module is opaque; the IR cannot prove every line inside it.
The framework deliberately has no separate pure-SPA mode. An application dominated by user-scoped data is a case the render planner derives, not a second application model that bypasses the server-first pipeline. Global mutable client stores are also outside the stated design: cross-feature state goes through public feature contracts.
If your existing application relies heavily on those patterns, adopting Hozu may require more than translating component syntax. Assess the migration at the boundaries: data ownership, routing, persistent UI and third-party integrations. Do not treat the existence of client components as proof that a particular integration is inexpensive.
Check the ecosystem fit before committing
Hozu has its own fine-grained DOM runtime rather than compiling to an established component renderer. Existing framework-specific components therefore are not drop-in Hozu views. The relevant question is whether its documented capabilities cover your application and whether the remaining integrations fit a client component's boundary. The repository does not provide an ecosystem-size benchmark, so this guide does not invent one.
The server side is less tied to TypeScript. Since 0.22, runs: 'server' effects can be implemented in a Go service through remote(), with a contract that hozu gen writes from the declarations, while access, caching and the output check stay in the Hozu server (ADR 0068). A trial agent moved a shop admin's order lifecycle, inventory and dashboard statistics to Go; its own verdict was to keep TypeScript unless a Go service already exists or a measured need asks for one (ADR 0070). The boundary also costs a process hop per call, which only pays off when a resolver does real work.
Some of what mainstream component frameworks give without asking had to be added deliberately. 0.25, for example, keeps one element when both branches of a condition have the same shape, so focus stays, and adds declared keyboard shortcuts (ADR 0072). Expect to find such gaps; the changelog records each one as it closes.
A small exploratory feature can answer more than a general promise. Scaffold it, inspect its declarations, make a realistic change and verify the result:
npx hozu add feature notes --page /notes --with detail,remove
npx hozu map
npx hozu check
npx hozu get /notes --forms
Choose a familiar framework when its existing components, team experience or required application model are more valuable than Hozu’s explicit checks. Consider Hozu when inspectable behaviour and data boundaries match the problem, and budget for learning its authoring surface. The useful decision is the one supported by your own representative task, with the published trials as context rather than a guarantee.