Build software from a document, not a chat log.

deffo is a guided app builder. A grilled conversation turns your idea into a shortform PRD; the PRD derives a connected task graph; agents execute the atoms against machine-checkable criteria — while live status flows back into the document you actually read.

Local-first · Postgres · web, desktop, and mobile

01Why deffo

Your idea stays legible while the agents do the work.

No terminal views. No endless chat logs. One document you can read in five minutes — and it is the control surface, not a note you wrote once.

The PRD is the product

Everything lives as a node tree. PRD, flow, and board are views of the same data. Edit the document and the work updates.

Done is a verdict

Atoms carry machine-checkable acceptance criteria. Agents loop until they pass. Nobody ticks a checkbox to declare success.

Verification, not vibes

Diffs, test results, evidence cards — never a scrolling terminal. Generation and verification are separate workers.

Changes go through review

Proposals flow draft → reviewed → accepted, and accepted is immutable. No silent mutations anywhere in the system.

Autonomy per task

Ask, edit-with-approval, or fully autonomous — a property of each atom, not a global mode switch you forget to turn off.

Secrets stay secret

The server stores names, domains, and policies. Values are injected at the transport layer — the agents never see them.

02How it works

Five steps from idea to verified work.

01

Grill

A chat that interrogates your idea — hard questions, short answers — until it can write a shortform PRD you agree with.

02

Derive

The PRD becomes a connected task graph: epics → nodes → atoms, with dependencies the scheduler can reason about.

epicsnodesatomsdependencies
03

Execute

Agents run atoms in git worktrees under a smallest-change constitution. The scheduler self-blocks on unmet dependencies — nothing starts on a shaky foundation.

04

Verify

A separate worker checks the result against the acceptance criteria: the diff, the run, the evidence. No implementer grades its own work.

05

Flow back

Status lands in the PRD live. Completing work updates the document; editing the document updates the work. The loop never desyncs.

03Verification

No implementer grades its own work.

Every atom ships with a verdict, not a promise. Speed up verification, keep diffs small, and treat evidence as a first-class surface — the same way you would review a teammate's PR, at agent speed.

  • The diff, first. Small, reviewable changes — not a wall of terminal output.
  • Tests as evidence. The run and its results attach to the atom that produced them.
  • Separate workers. Generation proposes; verification decides. The loop repeats until the verdict is passed.
04Under the hood

Deterministic where it counts. Judgment only where it matters.

System 1 before system 2

Deterministic code schedules, blocks, commits, and streams realtime. LLMs are reserved for planning, implementing, and reviewing.

Lossless journal

Every state change is an append-only event. The whole UI is a pure function of the log — replayable, auditable, never silently rewritten.

Local-first

Runs on your machine via docker compose, or against your own Postgres in the cloud. Multiuser-capable from day one.

Not from zero — optionally

Start from techstack blueprints at any level — concept, specified, or executable — or start a completely bare project.

Point it at an idea.

The grill chat does the rest — PRD, graph, agents, evidence. You keep the document.

Runs locally in minutes — Postgres via docker compose, then pnpm dev.