The App Is YAML

Use it, then talk it into becoming yours

The wish

You already know the tool you wish existed

A project tracker with a Kanban board and due dates. A custom CRM for customers, deals, and follow-ups. A research notebook. Universal App's bet: you should get it by talking, not coding.

First question: is this real, or just a design doc?

Project tracker — Kanban board, due dates, team assignments
Custom CRM — "track customers, deals, and follow-ups"
Research notebook — collects your thinking

Working framework · not a shipped product

The proof

This is a real, actively-built codebase

2,338 commits over ~6.6 weeks (2026-02-19 → 2026-04-06), built on Svelte 5 + Vite 6 + Tauri 2 with a Rust sidecar.

It exists and it's substantial. So why not just build apps the normal way?

2,338

commits in ~6.6 weeks

32,719

lines across src + src-tauri

110

test files

57

Svelte block components

The dead ends

Every existing route makes you a programmer — or gives you a throwaway

A code editor or low-code builder turns you into a developer. A one-shot generator hands you a disposable artifact. Universal App lists both as explicit Non-Goals.

So the design needs a third path — and it starts with one rule.

Not a code editor or development environment — users never see code
Not a low-code / no-code drag-and-drop builder — the interaction model is natural language
Not a platform for professional developers — the target is end users

The rule

"Worse Is Better": the whole app is the simplest thing that works

The design's first principle deliberately picks the simplest AI-facing representation. No ASTs. No component trees. No type hierarchies.

Everything is measured against one litmus test.

The Litmus Test — "If an LLM can't reliably read it, modify it, and explain what it did in one turn, it's too complex."

The substrate

So the app is one flat YAML substrate

schema_version 1, a flat list of 31 block types, spreadsheet-style = expressions, and behaviors as first-class YAML objects — triggers like page_load and timer, actions like set_state.

That simplicity is what lets you edit it just by talking.

# a behavior — first-class YAML, not hidden code
id: status-auto-refresh
trigger:
  type: timer
  interval_ms: 60000
  page: status
actions:
  - type: set_state
  - type: set_state

# and a reactive expression, inline
content: "Hello, ={name}!"

The loop

You don't start from a blank canvas — you open a designed app and talk to it

Four complete experiences ship as YAML (productivity-hub, agent-workspace, demo, file-explorer). Chat builds a page-context prompt and sends it to an Amplifier sidecar; a Tauri watcher live-reloads the YAML.

Using edits into building — and the line between them starts to vanish.

Open a complete designed experience shipped as YAML
Say what you want — chat calls sidecar.send('chat.send', {message, systemPrompt})
The edit lands in the YAML file
A Tauri watcher (500ms debounce) reloads — no rebuild

The payoff

"The boundary between using an app and building an app dissolves — no user mode vs developer mode, just a smooth gradient of depth."

— ARCHITECTURE.md, lines 44 and 125–126

The pattern

Make the representation LLM-native, and the line between users and builders goes away

Universal App proved it on itself — 121 features completed, driven largely by an autonomous dev machine. When software's representation is simple enough to read and edit in one turn, editing-by-talking replaces building.

The tool you wish existed becomes a conversation away.

31

block types in one flat schema

121

features completed (STATE.yaml)

~94%

of commits by Sam Schillace (2,194)

4

designed experiences shipped as YAML

Sources

Research Methodology

Data as of: 2026-04-06 (last commit 7dc778e9) · Feature status: Working framework — not a shipped consumer product

Primary source: ramparte/universal-app, checked out at ~/dev/ANext/universal-app. Every claim re-derived from live command output.

Commands run:

Commits & span: git rev-list --count HEAD (2,338); git log --reverse --format='%h %ci %s' (2026-02-19 → 2026-04-06)
Substrate: cat schema/page.schema.json (schema_version 1, flat blocks, 31 block-type enum)
Behaviors: cat workspace/shared/status-monitor/status-behaviors.yaml (status-auto-refresh: timer/interval_ms 60000, set_state actions)
Talk-to-edit: grep -n 'sidecar.send\|chat.send' src/lib/chat/submitHandler.ts
Live reload: grep -n 'from_millis\|yaml' src-tauri/src/watcher.rs (500ms debounce)
LOC / tests: find src src-tauri \( -name '*.ts' -o -name '*.svelte' -o -name '*.rs' \) | xargs wc -l (32,719); 110 test files; 57 Svelte components
Features & authors: grep 'count:' STATE.yaml (121); git log --format='%an' (Sam Schillace 2,194 ≈ 94%)

Gaps: The live real-backend "talk → structured edit" loop was not executed (submitHandler notes real tool calls will replace the traced path); npm test / build were not run — LOC and test-file counts are filesystem counts. End-user outcomes are design intent, not measured.