The Machine That Builds the Apps

• Day 1

  I'm caelum0x42. Solo dev. I'm building a whole studio of apps in public — Erebos Lab — and posting the real version: the bugs, the bad architecture calls, the metrics that currently read 0. Day 1 of 365. Let's see if one person can ship a fleet.

• Day 2

  The bet: one dev + a disciplined agent workflow can ship what used to need a team. Not vibes-coding. Real tests, real release gates, real App Store review. If it faceplants in public, that's still the most honest content I could give you.

• Day 3

  The fleet: Aether (self-custody wallet), Huddle (team chat), Cipher (daily code game), Vertex (timing game), CalDesk (nutrition AI), GhostOS (assistant), Echo (voice journal), Bump (alarm), Calc+ (vault), Better Notes, CalGym, TracePace. Twelve shots.

• Day 4

  Honest status, day 4: near-zero users everywhere. I have code, not traction. The real question this year isn't "can I build it" — I can — it's "can one person solve distribution." Building is proven. Distribution is the boss fight.

• Day 5

  First decision for the whole studio: a shared core package. Auth, storage, telemetry, billing, error handling — written once, imported everywhere. Rebuild login twelve times and I lose the year. Leverage is the only reason a solo fleet works.

• Day 6

  The 80/20 of portfolios: ~80% of the code across twelve apps is identical plumbing. The 20% that differs IS the product. So I automate the plumbing to death and spend every creative token on the 20%. That ratio is the whole strategy.

• Day 7

  How I actually build: a multi-agent loop. A planner drafts the change, an implementer writes it, a reviewer tears it apart, a verifier runs the gates. I'm the editor-in-chief, not the typist — my job is taste and saying "no, do it again."

• Day 8

  The failure mode of agent-built code is false green: the agent says tests pass, and they didn't run, or tested nothing. So the verifier doesn't trust prose — it runs the command and reads the exit code. "Trust me" is not a test result.

• Day 9

  Monorepo layout locked: packages/core (shared), apps/* (thin shells), one CI pipeline parameterized per app. Same gates for all twelve. Shipping app #7 is genuinely ~5x faster than app #1 was. The plumbing compounds.

• Day 10

  Why twelve apps instead of one? Because I don't know which one wants to exist yet. Twelve cheap bets beat one expensive guess. Kill fast, feed the survivors. The portfolio isn't indecision — it's a search with a small step size.

• Day 11

  Set up telemetry across the fleet. Privacy-first: no data selling, minimal collection, anonymized. I want to know if a screen crashed, not who you are. You shouldn't watch people who never consented — but you can't fix what you can't see.

• Day 12

  Commit discipline is a feature. Small commits, imperative messages, one logical change each. git log is the only project doc that never lies. When prod breaks I want git bisect to hand me the exact commit, not a mystery.

• Day 13

  🧵 Thread: how I run a 12-app studio as one person. The whole thing stands on ruthless reuse.

  • packages/core: auth, storage, analytics, billing, errors. Apps import it. They never reimplement it.
  • Each app is a thin shell: its screens, its logic, its personality. That's it.
  • One CI pipeline, parameterized per app. Twelve apps, one set of gates.
  • One design system — tokens, not pixels. Rebrand by config, not by hand.
  • Payoff: app #7 ships 5x faster than app #1. Leverage is survival, not luxury.
• Day 14

  Named the studio Erebos Lab. Erebos = the primordial dark before light — fit a workshop full of half-built things nobody's seen. The bigger factor: the handle was free on every platform. Naming is 50% poetry, 50% availability.

• Day 15

  Design system is tokens, not screenshots. Color, spacing, radius, type scale live in one file. An app rebrands by swapping a config, not touching every screen. When you're one person, "change it in one place" is the only way.

• Day 16

  Shipped the first internal build of Cipher. It runs. It's ugly. Nobody's played it. That's exactly the right amount of done for day 16. A thing that exists and can improve beats a perfect thing that doesn't. Ship the skeleton.

• Day 17

  Decision log is now a daily habit. Every non-obvious call gets one line: what, why, what I gave up. Future-me is a stranger who will ask "why is it built this way." I'm leaving him notes so he doesn't rederive it at 2am.

• Day 18

  Unpopular opinion: "move fast and break things" is malpractice for a wallet and fine for a puzzle game. Risk tolerance should scale with blast radius. Cipher can ship rough. Aether touches your keys — that one gets the paranoid pipeline.

• Day 19

  Killed a feature today before writing a line of it. Wrote the announcement tweet first, read it back, and it bored even me. If I can't make the pitch interesting, the feature won't save it. The announcement is a cheap unit test for the idea.

• Day 20

  The agent loop's best side effect: it forces me to write the spec first. To hand off a task I have to state acceptance criteria clearly enough for a machine. That's most of the thinking. Half my "bugs" are specs I never wrote down.

• Day 21

  Three weeks in. The apps are still tiny. What's gotten strong is the machine: the core package, the gates, the review loop. Boring infra weeks are the ones nobody claps for and everything depends on. Build the factory before the cars.

• Day 22

  Cost reality of an agent workflow: tokens aren't free. I route cheap mechanical work — renames, boilerplate, test scaffolds — to a small fast model and save the expensive one for architecture and gnarly bugs. Model selection is a budget line.

• Day 23

  A thing I got wrong: over-abstracted the core early. Built a plugin system for a problem I didn't have yet, ripped it out for a plain function. Rule relearned: abstract on the third repetition, not the first. Two points is a coincidence.

• Day 24

  Shared error handling paid off today. One app threw a weird crash; because every app pipes errors through the same reporter with the same context, I had the stack, the screen, and the version in one place. Write once, debug all twelve.

• Day 25

  🧵 Thread: what the AI actually does here, and what I do.

  • AI: keystrokes, boilerplate, test scaffolds, first drafts. Fast, tireless, cheap.
  • Me: which schema, which tradeoff, what to NOT build — the calls you can't cheaply undo.
  • AI: "here are three ways to do it." Me: "none — here's the constraint you missed."
  • AI hands me green tests. Me: the one who runs them and checks they assert anything real.
  • The typing was never the bottleneck. Judgment was, and that part didn't get automated.
• Day 26

  Hard rule: no merge without a green pipeline, ever, including me at midnight. The one time you wave a red build through "just this once" is the time it ships the bug. A gate only works if it's never negotiable.

• Day 27

  Refactored the core's storage behind a repository interface: findById, save, delete. Apps talk to the interface, not the database. Swapped a local store for a synced one in one app today and touched zero screen code. That's the payoff.

• Day 28

  Month 1 lesson: the constraint was never ideas or code. It was leverage. Shared core, one pipeline, the agent loop, tokens-not-pixels — all of it buying leverage so one dev can carry twelve apps. Next month I go deep on the hardest one.

• Day 29

  Picking Aether (the wallet) for next month because it has the least room for "eh, good enough." Money bugs aren't bugs, they're incidents. Build self-custody I actually trust, and every other app in the fleet is downhill from there.

• Day 30

  30 days in, still ~0 users, not discouraged. I have a working build machine and twelve apps that exist. The year's real work — distribution — hasn't started. This month I built the factory. Now I find out if anyone wants what it makes.

← All build-log months