Personal finance, actually personal.

What was built

A budget app for a household of two.

Flow is a mobile-first web app my wife and I open every day: Budget Bars referenced against our own seven-year averages, spending insights written in sentences instead of charts, savings goals, an emergency-fund tracker, and a recurring system that keeps the data alive without a bank connection. It was never meant for an app store — it was meant to answer one household’s question precisely.

One fact belongs this early: I designed and directed; Claude implemented — every screen, the schema, the historical import — under written rules it could not bend. The full method, pipeline and all, closes this study.

The problem

The price of every budgeting app is the data.

We couldn’t say where our money was going — the usual reason people reach for a budgeting app like Mint or YNAB. But every one of those services starts with the same ask: connect your bank accounts, or upload your statements. A bank statement is the most complete record of a life that exists — every merchant, every habit, every place you’ve been. I wasn’t willing to feed that to a third party to find out we eat out too much.

So the product decision came before the product: build our own, and treat the data boundary as a feature. The discipline went all the way down — even the AI that built the app worked from statements I had redacted first.

The founding act

Born with seven years of memory.

Most budget apps fail the same way: an empty screen, a month of dutiful data entry, then abandonment. Flow’s first feature was the opposite — before the interface existed, a one-time Claude-driven import read seven years of redacted statements and reconstructed our entire history: every transaction categorized, ownership assigned, card payments excluded so transfers never counted as spending.

The first screen Flow ever rendered already knew our habits. Budgets weren’t guesses typed into boxes — they were seeded from what we had actually spent, category by category, and every Budget Bar carries its seven-year average as a reference line. Import before interface is the structural decision everything else in the app stands on.

The interface

Real screens, calm by design.

These are real screens from the live app — the one my wife and I open every day — shown with sample data so the design does the talking, not our grocery bills.

The interface earned its calm the hard way: three complete visual identities in ten days — it started warm and editorial, passed through an enterprise-density experiment, and finally settled on the dark system you see now, specced as calm financial confidence. An app you open every day about money must feel like neither a spreadsheet nor a casino.

Add-transaction bottom sheet — amount, merchant autocomplete, category pills, owner pills. Sample merchants and amounts.

Insights drill-down — a category or tag view with an implication-first insight line above its chart. Sample amounts and merchants.

Category drill-down — necessity split or sub-tag breakdown view. Sample amounts and merchants.

Fig. 4 — Real screens from the live app, shown with sample data.

From data to meaning

Insights that read like sentences, not stats.

Seven years of data is worthless as a wall of numbers. The insights layer was rebuilt around a single rule, written into its spec:

So a drill-down doesn’t say “$1,039 / 52%” — it says a single merchant absorbs more than half of everything in the category. Tag and sub-tag breakdowns, merchant correction, and category drill-downs all answer to the same sentence-first standard.

Every insight line in the spec carries display conditions: a merchant above half its category absorbs; below half, it merely leads; a peak month is named only when one exists. Most budgeting apps render numbers — Flow’s insight layer renders judgment with thresholds, which is why the lines read as if someone looked at the data rather than queried it.

Insight pair — two category/tag views, each with its implication-first sentence above the chart. Sample amounts and merchant names.

What seeing it changed

The subscriptions nobody remembered buying.

The first honest outcome arrived within weeks: a set of subscriptions we had been paying without noticing — visible the moment seven years of recurring charges sat in one place — was cancelled. Not because an app nagged us, but because the data finally made the question impossible to avoid. We are simply more conscious of where the money goes now; that was the entire point.

Two features turned that awareness into structure. The necessity split tags every transaction essential or discretionary, with a review queue for the ambiguous middle. And the emergency fund view answers the question underneath all budgeting, computed from our real essential spend and mapped onto the actual savings balance:

Subscriptions pair — the forgotten recurring charges surfaced, and the keep/cancel decision beside them. Sample merchants and amounts.

The hardest design problem

No pipe to the bank — by design.

No bank connection meant the defining tension: statements can’t be imported weekly, but stale data kills a budget app. How does the ledger stay current without the pipe every competitor depends on?

The answer is the recurring system, built on a distinction most apps flatten: rent is constant, utilities are not. Constants post themselves as templates; variables ask one question — a push notification for one number, one tap to confirm. The constraint that looked like a weakness became Flow’s most original engineering.

Underneath is machinery, not a reminder list: each cycle a scheduled job walks the templates — constants confirm themselves, variables raise one notification. Thirteen run live, twenty-two sit paused. The monthly import stays the backstop, so the ledger is never more than one tap from true — the quiet center that keeps a pipe-less app honest.

Recurring pair — income grouped by employer, and the active/paused expense templates beside it. Sample amounts, merchant and employer names.

The method, second time

The same loop, pointed at a product.

Flow used the same workflow that built this site: every feature began as a dated design spec the AI couldn’t re-litigate, with two design-rule documents fixing type, color, and interaction before any UI was generated.

The chain: ideas in Cowork, specs and build in Claude Code, verification in a headless browser, data on Supabase, deploys through Vercel — fronted by a redaction gate no statement crosses unscrubbed.

The stack was a product decision, not a fashion one: React + TypeScript (the dialect AI implements most reliably), an installable web app (a URL on both phones, no app store), and Supabase (Postgres with the ceremony removed).

The iteration story is written in the repo’s own filenames: the home screen was specced and rebuilt three times in two days (April 15–16); the insights surface took five specs in forty-eight hours before the sentence-first version survived; and the entire visual identity changed twice — a warm editorial system, then an enterprise-density experiment — before calm financial confidence stuck. Cheap regeneration is what made that standard affordable; the dated specs are what kept every rejection on the record.

The honesty extends to the worst day: a corrupted git operation once produced a commit deleting 70,508 lines — nearly the whole repository. The recovery was methodical (rewind, re-stage only the real change, verify the build), and the lesson was written into the project’s incident log so no future session repeats it. Working with AI at speed doesn’t remove the need for discipline; it raises the price of not having it.

Honest outcome

What holds, what’s open.

Holds: live in production, opened daily by both users — a market of two with full adoption and zero churn. Forgotten subscriptions cancelled, budgets grounded in seven years of real behavior, the data still home. It outlived the phase where side projects die: the novelty wore off; the daily use didn’t.

Open, and named: categorization is imperfect — some transactions still tag wrong, and drill-downs need better correction tools. 79 of 365 tests fail — inherited debt, logged, never release blockers; the 24 guarding the newest system are green. A budget app is never finished; this one is honest about where it isn’t.

Why this case is here: the site you’re reading proves the workflow; Flow is that workflow shipping a real product — backend, database, tests, two daily users whose behavior changed. Not portfolio-specific. That was the claim; this is the evidence.