A personal operating environment you can have a conversation with.
Describe what you want. Get a working app. Modify everything with natural language.
Non-technical people have clear ideas for tools they need — project trackers, CRMs, expense trackers — but no way to create them without developers.
Low-code platforms trade text for UI but still expose programming concepts: variables, conditionals, loops, API wiring. Complexity shifts, it doesn't disappear.
Current AI app builders generate artifacts on demand. "Make me a chart" → here's a chart. That's generation, not an environment you live in and evolve.
The boundary between "using an app" and "building an app" should dissolve. Users should start with something that works — and evolve it by talking to it.
Every successful universal platform won by being simpler than the thing it replaced:
"If an LLM can't reliably read it, modify it, and explain what it did in one turn, it's too complex."
The representation must be so simple that modification is boring. YAML files. Flat lists. Spreadsheet formulas. No ASTs. No component trees.
Universal App is a designed application — opinionated, polished, immediately useful — that happens to be infinitely malleable through conversation.
Users never see an empty canvas. They start with complete, designed experiences — a Command Center, Project Space, Research Notebook — that work out of the box.
Every element — every block, behavior, design token, layout decision — can be referenced, modified, and explained through natural language.
Automations aren't hidden scripts. A morning briefing, an alert rule, a reactive binding — all visible, inspectable, conversationally modifiable.
The user opens it and sees a beautifully designed command center for their day. They use it. It works. Then they say "move my calendar to the left" and it just... changes. The boundary between using and building dissolves.
The AI and the user interact with the same YAML substrate through different interfaces. Both are first-class citizens.
Tokens, constraints, themes, UX analyzer — "Everything looks good, even after the AI changes it"
Amplifier integration, tools, contextual focus — "The AI reads, understands, and modifies YAML"
Tauri + Svelte, rendering, transitions — "Rich designed experiences from simple definitions"
Expression evaluation, dependency graph — "Spreadsheet formulas for app behavior"
YAML on disk, flat block lists, schema — "The simplest possible thing that works"
Rendered experiences — beautiful, interactive, responsive. No YAML, no code, no configuration panels.
YAML files — flat, readable, modifiable. The reactive engine and design system handle everything else.
Every change follows the same pattern — and the user sees the experience evolve, not reload:
User speaks intent. The AI reads the current page YAML to understand context, layout, and existing blocks.
Adds a data-source block and a metric-card block to the page. Flat list insertion — no tree navigation, no nesting complexity.
Rust notify crate picks up the YAML change. Diff engine identifies new blocks. Reactive engine evaluates expressions.
New blocks fade in. Layout smoothly reflows. Design system validates visual coherence. The user sees a weather widget appear — no page reload.
Flat block lists, not nested trees. Reactive expressions like spreadsheet formulas. Simple enough to be boring.
The design system is the quality floor that prevents conversational modification from producing visual chaos.
Design tokens resolve through a 5-level hierarchy: block → page → experience → theme → global. The AI says style: body, the system handles the rest.
No font-size: 17px. No color: #FF0000. The AI uses semantic tokens — variant: "alert", position: sidebar — and the theme resolves them.
Post-modification validation checks contrast ratios (WCAG AA), touch targets (44×44px), information density, visual balance, and typography hierarchy.
Dashboard builders start with empty canvases and widget palettes. Universal App starts with designed experiences that already work. Customization is evolution, not construction.
HyperCard was a construction kit. Universal App is a thing you use that happens to be modifiable. The construction capability is a property of the experience, not the point of it.
All data in this presentation is drawn from the live repository and verified via git history. No metrics are fabricated or estimated.
universal-app at /home/samschillace/dev/ANext/universal-app/git log --oneline --no-merges — 2,338 total commits, 1,941 in last 60 daysgit shortlog -sn --no-merges — Sam Schillace (2,193), Dev Machine Monitor (144)find src -type f | wc -l — 170 files; wc -l on all .ts/.svelte — ~31,975 linesSTATE.yaml completed_summary.count: 121ARCHITECTURE.md (3,136 lines), PROJECT-INTENT.md, STATE.yamlKey design concepts — "worse is better," the litmus test, five-layer architecture, flat block lists, reactive expressions, token cascade — are quoted or paraphrased directly from the project's ARCHITECTURE.md and PROJECT-INTENT.md.