Two Weeks Inside the Machine

Over the last two weeks, I’ve been laying the groundwork for a new ecosystem:

This isn’t a lift-and-shift. It’s a philosophical rebuild: tokens first, contracts over templates, content models that survive platform change.

The Cast

This work has not been solo.

Session Limits: The Invisible Constraint

Claude-Code: “We should think carefully about architecture and long-term coherence.”

Claude-Code is excellent at what I think of as beautiful coding: strong abstractions, careful reasoning, and clean architectural framing.

The problem is endurance.

Me (90 minutes in): Great, we’re in flow.

Claude-Code: “I regret to inform you that I am out of processing budget.”

Credits disappear quickly—usually after about 1.5 hours of real work.

So I’ve been splitting the labor:

This works—until documentation enters the picture.

Documentation Is Not Optional

To make any of this viable with AI, I’ve had to generate a significant amount of documentation:

This isn’t bureaucracy. It’s externalized memory.

Me: “Codex, here are the docs. Please reason across them.”

Codex: “I can reference up to 25 files.”

I have more than 25 files.

Me: “What if we merge and dedupe the documentation?”

Codex: “Please provide one document. Only one.”

Codex does not enjoy comparing large documents. Claude-Code would happily help—but has already run out of credits again.

The Storybook Realization

While asking Codex for a component migration prompt, it casually assumed the existence of Storybook.

Codex: “Once implemented, document the component in Storybook.”

Which is when it occurred to me:

That’s another repo.

At this point I already had:

So I asked whether this was actually best practice.

Codex: "Have you considered a monorepo?"

This sounded wonderful. Briefly.

Codex: “Monorepos are not recommended if you plan to reuse your design system across many independent projects.”

This is where intent matters.

I’m not building a venture-scale platform. I’m building a mini ecosystem for a portfolio site. The system is platform-agnostic in philosophy, not because I plan to operationalize it across many products.

Where I Landed

Instead of deciding immediately, I asked Codex to generate a PRD for a monorepo using my existing PRDs for:

That document clarified boundaries, tradeoffs, and intent—but it’s a topic for a separate post.

What This Gem Captures

Claude-Code: “Next time, we shall design the monorepo with elegance.”

Codex: “Please provide fewer documents.”

Me: We’re all doing our best.

Addendum: Two Weeks Inside the Machine — “The Assistants Who Wouldn’t”

A small confession about tools, trust, and the weird sociology of automation.

There’s a special kind of modern fatigue that doesn’t come from doing hard work. It comes from doing precise work while being uncertain whether it matters. That was me, for hours, line-by-line, dutifully executing git commands like a Victorian clerk stamping forms while the factory roared behind the walls.

The scene: Sugartown’s monorepo migration. The mission: preserve history, don’t refactor, don’t get clever, don’t touch runtime behavior, don’t create new abstractions, don’t sneeze near the design system. I wrote rules like a stern librarian. I meant them. I still mean them.

The Codex Problem

“Unable to proceed… source repositories not available… network access… authentication…”

Codex wasn’t being difficult. Codex was being honest. It couldn’t see my local directories. It couldn’t borrow my SSH keys. It couldn’t safely operate a live git graph with missing context. So it did what a cautious system does: it stopped.

The irony is that I had designed the constraints to force that behavior: “If something breaks, stop and report instead of fixing creatively.” Codex followed the rules like a trained engineer. I followed the rules like a sleep-deprived pilgrim trying to reach the shrine of Parity.

And then—this is the part that will sound familiar to anyone who’s ever wrestled a tool into cooperation—I spent hours trying to “make it work” anyway.

Not by hacking the repo. Not by rewriting history. By attempting to brute-force a mismatch between what I wanted (autonomy) and what the system could safely do (guided assistance).

The Claude-Code Counterexample

Claude: “Looking at this document, I can definitely help complete this migration.”

Claude then ran a handful of commands, calmly assessed the actual repo state, discovered the hilarious truth—the migration was already done on the branch—verified parity, committed the lockfile, and pushed main.

The whole thing felt like watching a professional mechanic walk into a garage where you’ve been disassembling an engine with a butter knife, glance at the situation, and say: “You’re holding the wrong end of the wrench.”

Home Truths (The Unromantic Kind)

  1. Automation isn’t “smartness.” It’s access + context + permission. Codex didn’t fail because it was dumb. It failed because it wasn’t me: no filesystem, no keys, no network route, no interactive control over the situation I was living inside.
  2. Rules are a form of fear management. I wrote strict constraints because I’ve been burned by “helpful” refactors, and because I know how costly it is to lose provenance during migration. The rules were correct… and they also created a maze where only the tool with the right kind of live execution context could move quickly.
  3. Time sinks often come from not knowing what state you’re in. The moment Claude said, essentially, “Main is behind; this branch already contains the world,” the fog lifted. Not because it was advanced—because it was concrete.
  4. “Tricking the tool” is sometimes just… creating the missing artifact. I didn’t outsmart Codex. I produced the one thing it could reliably generate: a handoff doc. I turned a blocked execution agent into a writing agent. That’s not cheating. That’s systems thinking.

A Small Confession

I wanted the machine to carry me through the boring parts. I wanted obedience. But what I actually needed was situational awareness: what branch am I on, what has already landed, what still needs merging, what is real, what is merely “not yet visible.”

The most humbling part is that the work wasn’t “hard git.” It was social git: coordinating intent, state, and trust between multiple agents and a repository that doesn’t care about my feelings.

What I Learned (and what I’m keeping)

The takeaway isn’t “Claude good, Codex bad.” It’s this:

The best tool is the one whose constraints match the job’s risk profile. When identity, network access, and stateful operations matter, you want the agent that can actually stand inside your environment and verify reality. When you need crisp instructions, safe scaffolding, and non-creative compliance, you want the agent that stops instead of guessing.

In other words: Codex was the cautious pilot refusing to fly without instruments. Claude was the ground crew walking over, plugging in the missing cable, and saying, “Okay, now you can take off.”

And me? I was the passenger in seat 12A, quietly realizing I’d been trying to navigate by vibes.

Postscript: The monorepo is live. The history is preserved. Parity checks pass. The machine didn’t win. The machine was just… a machine. I had to learn where its hands end. And where my wallet begins as I may need to MAX out my Claude plan, at least until I get the heavy lifting of the Mini-Monorepo done.