It Wasn't Broken. It Was Quiet.
I called my own app three times before I found out it had been eating my data the whole time.
// Build One · alpha
Workhorse
The machine that builds. The Forge pipeline itself — the dispatch, the gates, the disciplines — and the dev tooling behind everything else I make.
The App Has a Name Now: Quilt
Phone calls that seemed to vanish weren't lost — and the tool I built to watch the work lied to me twice.
The Best Feature I Shipped Today Does Nothing
I built an insight engine whose entire personality is refusing to make something up. Also I shipped it with an invisible button. Again.
Five Bugs, One Clean Screen, and Two Bars I Almost Faked
The whole talk-to-your-phone loop went from dead to working live — then the design nearly tricked me into drawing data that didn't exist.
Every Tracker Counts You Down. I'm Building One That Adds Up.
I opened every top calorie tracker to learn from them. They all do the same quiet, punishing thing. So I'm building the opposite.
Four Strangers Read My Plan Before I Shipped It
I built a calorie tracker into my app and put it on my phone. The part worth telling is what four AIs caught before I shipped.
Patterns Are the Product
I thought I was building a health tracker. A day of wiring the design into a real phone showed me it was never that at all.
Proven, Not Assumed
The code was perfect. The goal would still have silently failed. Here's the reviewer that caught it, and the boot log that settled it.
Three Minds, One Cycle
My build pipeline runs as a cycle. This session I put three independent AI models on every step, and the new one caught a flaw the other two missed.
The Backup That Wasn't There
I'd built a backup for my journal that had never once run — and the fix was the one step almost everyone skips.
Lay the Track First
I gave my build assistant a memory, then spent the day saying no — and the most important no was to my own clever roadmap.
Sixteen to Six
My build pipeline had grown to sixteen steps. I cut it to six and it got safer, not sloppier. Here's the rule that made that possible.
Let Go and It Stops
An overnight audit graded my code B-minus. Twelve fixes later, every one says the same thing: when the system isn't sure, it stops.
When My Own App Lied To Me
The screen showed 'unscored' while the data sat right there. The bug wasn't the math. It was two screens reading two different truths.
Color Is Earned
I made my health app black and white on purpose. The rule for when color comes back caught a bug I couldn't see on a green test run.
Too Early to Tell
I built the part of the app that finds patterns in my own data — and the part I'm proudest of is where it refuses to.
Shipped Three Times Before It Worked
Clean code, a live deploy, real data in the API — and the feature still wasn't on my phone. The last mile was the whole mile.
Built Is Not Proven
A backup tool that passed every review still hadn't backed anything up. The day I made it touch the real vault.
Build the Thing, Then Let Reality Test It
I spent a whole session perfecting the plan for one safety feature. Then I built it, and one real run told me what eight rounds of planning couldn't.
Five AIs Approved the Fix. One Said Reject. The Loudest Wasn't the Truest.
Six AIs reviewed the machine I build with. Five approved, one rejected hard. The job wasn't to pick a side. It was to reconcile them.
Four Reviews Passed. The Only Vote That Counted Was My Thumb.
A feature I built fifteen sessions ago had never once run. Four AI reviews approved the fix; only my thumb on the button could prove it.
I Opened the App I Couldn't Open
Last week I shipped a fix to an app I couldn't open. Today I opened it, recorded one sentence, and using it found a bug weeks of building never could.
When the Check Is the Bug
Four AI auditors read my service worker twice and agreed it was fine. What they kept rejecting was the checks I'd written to prove it.
Cut the Option, Don't Guard It
Four audit rounds caught real bugs. The cheaper fix wasn't more guards — it was removing the option that created the risk.
The Recovery Doorway Comes First
I thought I had not used my own product for twenty-eight sessions. The database told a different story.
One token, one use, no boats
Multi-use tokens defended by policy can be replayed. One-shot tokens defended by structural commit at consume-moment cannot. Cortés knew this in 1519.
Defense at every approach
Three LLM auditors said the verify script was solid. The fourth auditor ran it. It wasn't.
Why Lincoln Picked Your React Renderer
In 1862 Lincoln signed a law about rail gauges. One hundred and sixty years later it picked my markdown renderer.
Walls Don't Stand on Dirt
Spent a day shipping an auth foundation. Production returned 500 on every signup. The root cause was below where I was looking.
Three Frames, Three Bugs I Couldn't See
A one-day foundation build where three external AI auditors caught three production-blockers I would have shipped without them.
Right-Size the Lock
The truck phone substrate went live end-to-end this morning. Then the actual question landed: how much lock does it need yet?
The Body Already Knows the Pattern
Twenty-seven days in, the voice-journal back half landed. The harder choice wasn't the code; it was the substrate it sits on.
The Discipline Becomes The Hardware
Some sessions you ship features. Some you ship the pipeline that ships features. Today was the second kind, and the math was clear.
Right-Size the Milestone, Not Just the Task
Yesterday's session shipped the platform. Today's session asked what I was actually trying to use it for, and the answer reshaped the whole roadmap.
Foundation Day
Cloud foundation shipped tonight. The full breakdown comes tomorrow with a clearer head.
The Day I Almost Built the Wrong Product
Caught the wrong-product trap at session 16 — pivoted from personal practice substrate to a privacy-first journal competing with Rosebud.
When the Audit Outweighs the Fix
Five-line fix. Sixteen hours of audit. The day the pipeline failed the test it was supposed to apply to the code.
When the Audit Disagrees with the Source
Eight sessions deep on a button that still doesn't work — the question that landed wasn't about the button.
Each Fix Is Permission To See The Next Bug
What I thought was a fix turned out to be permission to see the next bug. The recorder worked; the upload behind it didn't.
Track the Tracker, Then Diverge
The site's calendar only showed the current month. The site had no resume. Both fixes started as one artifact each, then turned into three.
When the Brake Handle Isn't Connected to the Brakes
The dashboard record button shipped yesterday. Today's verification ran into a sixty-second timeout that wasn't actually connected to anything.
The Audit Chain Pays Off Three Times Then Stops
Spent four prompt revisions and five external audits shipping a record button. Caught one real bug, eleven small ones, and a hard rule about when to stop.
Fix the Affordance, Not the Human
Opened my own dashboard and got a 500. The fix wasn't a bug fix. It was admitting the system was lying to me about what it needed to run.
The Author Cannot Audit Their Own Frame
A year-old bug caught at intake. Two rounds of internal review approved a flawed prompt. The third pair of eyes saw the timezone bug.
The Coach Doesn't Hit the Ball Better Than You
I shipped an AI mirror today that reads my journals. The part that matters isn't what it knows. It's what it sees.
Tripwires, Not Audit Logs
A week-two shortcut became six-week drift. The migration took an afternoon. The thing it taught took longer.
When Two Records Disagree, You Don't Have a Record
A vision document said one thing. Three sessions of code shipped another. Nobody on the inside noticed for ten days.
Rules Without Immediate Exercise Are Rules You Don't Have Yet
Three rules added to my build pipeline in one session, and the reason each one got run the same afternoon it was written.
Green Tests Can Lie
S2 cut from 5 tasks to 2. Express scaffold, Vitest baseline, and the principle: a safety check is only real if something tests that it fires.
First Blood
First Workhorse session: voice journal pipeline, site update, and the patterns that will carry every connector after this.
Two Repos From Nothing
S2 scaffolded the vault and Workhorse CLI from scratch so every future session has somewhere to write and something to run.
Seven Hours to a URL
Tortoise existed as a plan. Session 1 turned it into a public site with a deploy pipeline.
Hello, Forge
Forge is where the actual work happens — code committed, products shipped, prototypes that survive contact with reality.