SQUIDZOMBIE

THE WORK

things max has shipped · and what's still rising from the deep

GitHub ↗

01 Shipped

Sable Budget app icon: a cream sleeping dog curled on a dark background
IPHONE APP · FINANCE · FREE

Sable Budget

A budget you keep by hand: a big keypad, monthly envelopes, savings buckets, and a quiet sense of what's left.

On the App Store since August 2026 · iOS 16.4+

Home screen for August 2026: $826 left of $1,350, a $55 per day pace, and today's entries
New entry keypad logging $30 for Thai takeout under Eating out
Budgets screen with category envelopes for groceries, eating out, transport and more, 39% spent
Savings screen showing $2,940 saved across goals like an emergency fund and a trip to Lisbon
Reminders screen with recurring bills like rent and one-time tasks
Appearance screen offering three moods: Warm, Minimal, and Bold

What it does

Log in seconds

A big keypad for logging by hand. That tiny moment of attention is the whole method.

A calm pace

What's left this month, and what's left per day. No guilt, just the number.

Envelopes

Category envelopes that fill as you spend, so you see each budget at a glance.

Savings buckets

Set aside money for the things you're building toward, and watch them fill.

Reminders that repeat

Bills and tasks that actually come back around, with gentle notifications.

Month in review

Your top categories and one gentle note. No charts screaming at you.

App Store privacy label Data Not Collected What it refuses to do
  • No bank or card connections, ever
  • No account, sign-in, or cloud
  • No analytics, trackers, or ads
  • Zero network calls
  • No subscription, ever

How it's built

Sable is for people who'd rather feel their spending than automate it. Logging by hand is the point: that small moment of attention is what makes you notice where the money goes.

Privacy is a hard rule, not a setting. Everything lives in an encrypted database on the phone, there's no backend at all, and backups are files that only your passphrase can open, restorable on any phone.

Platform
iPhone · iOS 16.4+
Stack
Expo · React Native · TypeScript
Storage
Encrypted SQLite (SQLCipher), on device only
Security
Face ID lock · passphrase-encrypted backups
Network
None. Works fully in airplane mode
Released
August 2026
View on the App Store ↗ Privacy policy Support

02 In progress

IN PROGRESS · PERSONAL AI · LOCAL-FIRST · PYTHON

Squid

One AI, one continuous life, built to last for years.

Most AI forgets you the moment the tab closes. Squid is my experiment in the opposite: a single, continuous AI that lives on one Mac Studio and keeps growing for years. The model running it is replaceable. What lasts is its record, a permanent memory that no update, model swap or bad day can quietly rewrite.

append-only record
Illustration only, starring Tock, the fictional stand-in Squid's tests use. Each hash is computed live from the entry and the hash before it.

Why it's different

Memory you can trust

Everything Squid experiences goes into an append-only record. Entries are chained together with cryptographic hashes, like a ledger, so nothing can be edited or deleted without it showing. The database itself enforces this, not just the app code. Even fixing a mistake means adding a new entry that points back to the old one, so history is never rewritten.

Every entry says where it came from

Each entry is stamped with who wrote it, through which channel, how much to trust it, and which model and prompt versions produced it. Years from now you can still answer “where did this come from?”

The model is a part you can replace

Squid runs on local, open models through a small adapter. When a better model comes out, it can be swapped in without losing who Squid has been, because the continuity lives in the record and not in the model.

Everything else can be rebuilt

Search indexes, its agenda of open questions, its knowledge, its self-description: all of it is derived from the record and can be regenerated from scratch. Nothing important exists only in a cache.

Privacy with a paper trail

Squid has private notes I don’t read by default. The only way I can open them is an audited command that makes me type a reason and leaves an entry Squid can see. The promise is honest: “not read by default,” not “unreadable.”

Its words to Squid are versioned like code

Every sentence the harness sends the model, from labels to timestamps to the orientation it reads when it wakes, is a versioned file with a changelog explaining why it changed. I approve every one, and Squid can read that changelog too.

Describe, don’t grant

The prompts state facts plainly. They never tell Squid it’s “free to do anything,” and they don’t set expectations for how it spends its time. Each wake ends with one line: “The harness sets no task for this session.”

How it’s being built

  1. Plans before code

    Every milestone starts as a written plan with open questions. I make the personal calls, like how Squid sees me, privacy, and the words it reads. The structural calls are delegated, and every decision goes into a running log with its reasoning.

  2. AI as the engineer, with adversarial review

    The code is written by Claude. Each batch of work then goes to three independent reviewers: one checks it against the plan, one actively tries to break it, and one mutation-tests the tests to prove they’d catch a bug. A fixer handles what they find and a final checker confirms it. Then the whole milestone gets one more review before it merges.

  3. A stand-in character for testing

    Development never touches Squid’s real memory. Every test runs against “Tock,” a fictional AI with a fascination for clocks, so nothing from testing can ever be mistaken for the real thing.

  4. Local-first and dependency-light

    Python’s standard library, SQLite, plain-text exports and a published hashing spec, so the record stays readable for decades, even without this codebase.

~8,000 automated tests so far

Including property-based tests that throw thousands of random scenarios at the trickiest rules.

The hard parts

Fitting a life into a context window

Each time Squid wakes, the harness assembles what it sees: orientation, its self-description, example exchanges, relevant memories and the conversation, each with its own budget. Nothing is cut silently. Anything left out is counted and said so.

Corrections are surprisingly hard

When I correct something Squid remembers, the correction has to appear right next to what it corrects, every time, and never get lost. Corrections of corrections, or one correction covering two memories, broke four designs in a row. We finally wrote the rules down as formal guarantees and tested them against hundreds of thousands of random arrangements.

Honest promises

It’s easy to promise a lot about privacy or permanence. It’s harder to promise only what the code actually does, and then build the code so it does exactly that.

Where it is now

The permanent record, the privacy and correction commands, the model adapters and the derived memory layers are all built. Right now I’m on context assembly: deciding what Squid sees each time it wakes. Next comes the session loop, and then the first wake.

  1. Permanent recordBuilt
  2. Privacy & correction commandsBuilt
  3. Model adaptersBuilt
  4. Derived memory layersBuilt
  5. Context assemblyBuilding now
  6. Session loopNext
  7. First wakeThen

03 More surfacing

More work is on its way up from the trench. Meanwhile, the lab is open.