Inside the box
Every piece, counted.
No mystery meat. This is what the zip actually contains, counted from the shipped source, with the code shown verbatim. Organized by what you will do with it, not by package name.
- design-system components
- 132
- lines of production Dart
- 39,279
- build rules on rails
- 7
- quality hooks
- 3
- guided beats, Guide tier
- 11
Both tiers
Ship screens that look shipped
z_design is the design system Zovia's own apps run: 132 components across 114 files, as real source you own. Typography ramp, cards, buttons, fields, pills, snackbars, skeletons, spacing and color tokens. The rules that come with it mean every loading state is a skeleton and every write can be undone, so your first screen already behaves like a mature app.
- z_design: 132 components, tokens, app signatures
- Skeleton factories on data-loaded components
- Undoable snackbars wired into the write pattern
if (_loading) {
return ListView.separated(
itemCount: 4,
separatorBuilder: (_, _) => const SizedBox(height: ZSpacing.sm),
itemBuilder: (_, _) => ZCard.skeleton(height: 56),
);
}Both tiers
Run on your own backend, safely
zovia_core_base carries the backend layer: one call pattern from the app, cloud functions on your own Back4App behind it. Identity always comes from the session token, never from anything the client sends, and every row is locked to its owner. The starter ships working auth (email and password with verification and reset), an email OTP template, and a Google sign-in guide.
- zovia_core_base: ParseService and the call pattern
- Cloud templates: list.js, auth_otp.js, deploy README
- auth_service.dart: sign-up, login, verify, reset
// in the app
final raw = await ZoviaCore.instance.parse.callFunction<dynamic>(
functionName: 'saveItem',
parameters: {'text': text},
);
// in cloud/list.js on your Back4App
Parse.Cloud.define('saveItem', async (request) => {
const user = requireUser(request);
...
const acl = new Parse.ACL(user);
item.setACL(acl);
const saved = await item.save(null, { useMasterKey: true });
return serializeItem(saved);
});Both tiers
Guardrails that catch mistakes before they cost you
Seven build rules encode how Zovia builds: data through cloud functions, no client-sent identity, the design system everywhere, skeletons, undoable writes, local calendar time. Three hooks run automatically after every edit and warn the moment generated code drifts off the rails. A hook is a script, not a conversation: it costs zero tokens and never gets tired.
- CLAUDE.md: 7 build rules plus model economics
- check-dart-file.sh, audit-design-system.sh
- daily-update-check.sh: one briefing a day, never a nag
hits="$(grep -rnE "Colors\.(white|black|blue|red|green|grey|gray)|\bText\(|ElevatedButton|TextButton|OutlinedButton|\.withOpacity\(" lib 2>/dev/null || true)"
if [ -n "$hits" ]; then
echo "Design-system reminder (warning only): prefer Z components and tokens over raw Material." >&2
echo "$hits" | head -20 >&2
fiGuide tier
A tutor that hands you control
The Guide is 11 beats across two phases: a small website first, then running and extending the real starter app. Each beat pins a coaching level and a model, shows a working result, and records progress so any session resumes where you left off. Control shifts to you as you go; by the last beat you direct the build and Claude executes.
- learn/curriculum.md: beats W1 to W5, then A1 to A6
- /zovia: start or resume any session
- .zovia-progress.md: nothing resets, ever
### Beat A3: extend the list
- coaching_dial: guide
- model: sonnet, step up to opus if it gets hard
- concept: add a real feature with the design system and an undoable write
- how_to_deliver: extend the list feature (a second field, an edit, or a delete) ...
- win: "You added a real feature that looks and behaves like a shipped app."The token angle
It spends your Claude budget like the budget is its own.
The expensive tokens are never the ones spent writing code. They are the ones spent recovering from going wrong. Everything in this bundle is shaped by that fact, the same discipline we run our own studio on.
Right-size the model, every task
The bundle's CLAUDE.md makes Claude state each task's size and the model it deserves before starting, so you switch before the tokens burn, not after. The Guide's beats pin a model each.
Zero-token quality checks
The hooks answer 'did this drift off the rails' as scripts, instantly and for free, instead of as another round trip through the model.
Prevention over cure
The build rules exist because rework is where tokens actually go. A rule that stops a wrong turn is an order of magnitude cheaper than the recovery loop it prevents.
Memory that persists
CLAUDE.md and the progress file are read at session start. A fact captured once is never paid for twice.
From the bundle's CLAUDE.md: the size-to-model table Claude applies before every task
| Size | Typical task | Model |
|---|---|---|
| XS | typo, copy tweak, one-line fix | haiku |
| S | single-file fix, small widget change | sonnet |
| M | new screen on existing patterns | sonnet, step up if it drags |
| L | new feature with real design decisions | opus |
| XL | auth, payments, anything cross-cutting | fable, the tier above opus |
The full discipline, from the studio notebook: We don't run out of Claude tokens. This bundle is that post, packaged.