# The Machine That Builds the Apps

> Build log · Month 1 of 12

the studio itself. How one person runs a monorepo, a multi-agent build loop, and a shared core without drowning.

Day 1–30 · 30 posts · Building in public as @caelum0x4

**Day 1** — I'm caelum0x4. 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.

[Month 2: Aether: Building a Wallet I'd Actually Trust](https://ereboslab.com/blog/month-2-aether-building-a-wallet-id-actually-trust/) →

[← All build-log months](https://ereboslab.com/blog/)