Shipping "Books at Home" in Two DaysJump to section titled Shipping "Books at Home" in Two Days

I shipped "Books at Home" in two days.

Not a prototype.
Not a rough MVP.
A real app—on the App Store—with barcode scanning, iCloud sync, lending, wishlists, and a small statistics view.

When people hear that, they usually ask how. They expect a story about speed, intensity, or some clever trick.

The truth is simpler than that.

I didn't move fast. I just didn't wait.

The SparkJump to section titled The Spark

My wife and I live with physical books. The kind that quietly spread—onto shelves, bedside tables, and the floor near the bed. Over time, the collection grew into hundreds of books.

Do we already own this?
Who borrowed that copy of Thinking, Fast and Slow?
Why did we buy the same book twice?

We tried a few apps. They all felt slightly off. Too social. Too gamified. Poor UX. Ads everywhere. Too focused on reading goals when the real problem was much more basic: what do we actually have? Some just didn't feel right—and that's reason enough.

I wanted something that felt like Apple Books—but for physical books. Clean. Private. Functional.

So I built it.

Agency Over IntelligenceJump to section titled Agency Over Intelligence

Andrej Karpathy recently wrote about agency, and it landed immediately:

Agency is significantly more powerful and significantly more scarce.

Agency isn't raw intelligence. It isn't deep expertise or perfect preparation.

It's the quiet assumption that you can act—and adjust as you go.

When I started building Books at Home, I didn't first "learn" VisionKit or CloudKit. I didn't create a study plan or block off time to research.

I decided to solve our book problem.

Everything else was downstream of that decision.

Design Before CodeJump to section titled Design Before Code

Before writing code, I spent time thinking—not abstractly, but concretely.

What does this app actually need to do?

Not what could it do.
Not what would look impressive.

Just this:

1. Know what books we own
2. Find a book quickly
3. Remember who borrowed it
4. Track books we want to buy

That was enough.

I pictured the app while making coffee. A simple tab bar. A grid of covers. Search at the top. Tap for details. Long-press for quick actions.

No wireframes. No Figma. Just a clear sense of how it should feel.

Apple Books—but physical.
Quiet. Fast. Obvious.

Architecture Is Mostly CommitmentJump to section titled Architecture Is Mostly Commitment

Architecture tends to sound grand. In practice, it's mostly about committing and moving on.

I used SwiftData. Not because it's perfect, but because it's a good-enough choice for a new Apple app today.

I organized the code by feature. Because when I think "lending," I want to know where to look, even if Claude is writing the code, I would know where to look.

Each of these decisions could have been debated. None of them needed to be.

Most architectural regret doesn't come from making the wrong choice—it comes from delaying the choice entirely.

You can always refactor later. You can't refactor something that doesn't exist.

Product Sense Is Mostly SubtractionJump to section titled Product Sense Is Mostly Subtraction

The initial plan had more ideas than what shipped. Smart collections. Widgets. Reading goals. Borrower contact integration.

Most of it didn't make the cut.

At one point, I started adding a contact picker so you could select borrowers from your address book. Halfway through, I stopped.

Do you really need contact integration to remember that Sam borrowed a book?

A text field shipped. The picker didn't.

Same with smart collections. Useful, eventually. Not necessary now. If you have 50 books, you can scroll. If you have 500, we'll revisit it.

The wishlist is simple. The stats are modest. The lending reminders are basic.

None of that prevents the app from doing its job.

Coding Wasn't the Hard PartJump to section titled Coding Wasn't the Hard Part

Claude wrote about 95% of the code.

I'm not exaggerating. I described what I wanted, made decisions when options appeared, and course-corrected when things drifted. The actual typing of Swift? Mostly not me.

This isn't a story about AI replacing developers. It's a story about what becomes possible when implementation is no longer the bottleneck.

VisionKit already knows how to scan barcodes. SwiftData already knows how to sync with iCloud. Claude already knows how to wire them together.

My job was knowing what to build and why. The architecture decisions. The product cuts. The "good enough for now" calls.

When something didn't work perfectly, I didn't stop to debug it myself. I described the problem, got a fix, moved on.

The goal wasn't to write every line.
It was to ship something real.

Momentum Is a Side Effect of DecisionsJump to section titled Momentum Is a Side Effect of Decisions

Two days isn't about speed. It's about momentum.

Momentum comes from making small decisions quickly and letting them compound.

Once the data model existed, the UI followed naturally.
Once the UI existed, gaps became visible.
Once the gaps were visible, priorities became obvious.

The app didn't emerge from a detailed plan. It emerged from a sequence of committed steps.

What Agency Actually Looks LikeJump to section titled What Agency Actually Looks Like

Agency doesn't mean certainty. I wasn't sure everything would work smoothly. I wasn't confident there wouldn't be bugs or trade-offs.

Agency is acting anyway.

The app isn't complete. It isn't polished in every corner. It isn't exactly what I imagined at the start.

But it exists.

Last weekend, my wife and I scanned all 203 books. It took about fifteen minutes. Now we know what we own. When someone borrows a book, we track it. When we're at a bookstore, we check.

That's enough.

Build Like You Don't Need PermissionJump to section titled Build Like You Don't Need Permission

If you want to ship faster, the answer usually isn't better tools or deeper knowledge.

It's deciding that you're allowed to act before everything is clear.

What would you build if you trusted yourself to figure things out as you go?
What decision are you postponing because you're waiting for certainty?

The gap between wanting to build something and shipping it is rarely technical, or at least, not any more.

It's agency.

Books at Home isn't my cleverest code.
But it's real.
And it exists because I didn't wait.

Books at Home is available on the App Store for iPhone, iPad, and Mac.