Engineering as Procrastination

In about three hours one Sunday afternoon, I:

• pivoted unattended-claude from a personal-tool framing to an open-source piece I’d actually ship,
• live-verified the end-to-end path under both bin: claude and bin: happy,
• filter-branched 50 commits worth of internal codenames out of the history,
• wrote a public README with an honest comparison table against Claude Code, claude-auto-retry, Hermes Agent, OpenClaw,
• pushed v0.1.0, wrote a Homebrew formula that vendors the bun runtime, added a GitHub Actions workflow that auto-bumps the formula on every future tag.

The 30 days before that I’d done none of those things. I had 511 unit tests green. I had documentation. I had an interactive ucl plan grilling mode and a ucl doctor health check. I had everything except a single task that had ever actually finished end-to-end against the live claude CLI.

This is a specific shape of procrastination I don’t think gets named enough. It looks like progress because git is moving. It looks like discipline because there are tests. It looks like the right thing because every commit message is true. What it isn’t is shipping.

The Diagnosis

The thing I was building was supposed to schedule AI work overnight onto my idle Claude Pro quota. The actual blocker on me using it wasn’t the tool — it was that I didn’t have a single piece of work concrete enough to feed it. “Investigate X” or “write a thing about Y” isn’t a brief. The runtime needed scope · workdir · done-when. My todo list was free-form. The gap between “intent in my head” and “a task an unattended worker could finish without me” was where I was actually stuck.

So I built more features on the tool. Add a ucl doctor for preflight checks. Refactor the prompt builder. Add a bin: happy integration. Auto-update the embedded skills. None of those features bring the brief closer to existing. They are, every one of them, the engine layer of the system. I had no work at the brief layer.

That distinction is the whole diagnosis. Engineering is the engine. Brief formation is the part that turns intent into something the engine can run. The engine layer rewards you with passing tests, clean commits, satisfying compile errors. The brief layer rewards you with nothing visible — it’s just sitting down and deciding what done means, which is uncomfortable in a different way than debugging is.

So you do the comfortable thing. You add another engine feature. You write another doc explaining the architecture. You refactor. Every action is rational locally. The system as a whole goes nowhere.

The Unlock

What broke the loop wasn’t more thinking. It was an explicit interview. I opened a session and asked Claude to grill me on the project until I either committed to ship something or admitted I wouldn’t. The grill loop was a skill someone else had written; I didn’t have to design it. What it forced was specific:

• What is unattended-claude actually for? Personal tool, portfolio piece, or both?
• If portfolio, why this and not the simpler thing I’d been deferring?
• What is the minimum shape of v0.1, written down?
• Is anything in your proposed feature list personal therapy disguised as a product feature?
• What is “done” — in one paragraph, with no movable goalpost?

Each answer knocked another supposed-requirement off the list. The pivot from “personal tool” to “OSS demonstration” took about ten minutes; the squash of “what v0.1 includes” from twelve items to three took another five. At minute thirty I had a V0_1_SCOPE.md committed into the repo with a hard rule: anything that breaks while finishing v0.1 gets a less-than-ten-line fix, a skipped test, or a revert — never a “while I’m here let me improve X.” Once that file existed, the next two hours were a tight execution loop because the loop could be tight.

The grill didn’t tell me anything I didn’t already kind of know. It made me write the answers down and commit to them in a document that was harder to wave away than my own head was.

The Transferable Bit

The engineering-as-procrastination loop has a specific signature. Mine looked like this:

• the thing I’m about to add is more polish on a layer that already works,
• I haven’t used the system end-to-end this week,
• I can’t name the next output (not feature) the system will produce for me,
• “but it’s so close” is in my head.

Those four together = the loop is running. The exit isn’t another engineering session. It’s writing down what done looks like, and refusing to do anything that doesn’t move toward it.

I’m not going to claim this never recurs. The next workstream — a public skills library — has the same risk shape. The discipline isn’t a one-time crossing. It’s something you notice and break out of, and the better you get at noticing, the cheaper each break is.

unattended-claude lives at github.com/wickes1/unattended-claude. The discipline lives somewhere harder to install.