Sometimes I Don't Even Bother Running Claude Interactively

This happened yesterday, verbatim:

Then I went and made a sandwich.

No session. No watching tokens stream by. No "looks good, continue." The -p flag runs Claude headless — one prompt, no conversation — and the reply above is everything I saw until the thing was live.

Read that reply again

It's worth unpacking, because nothing in it is code completion:

• "Cluster kilter-kanban42 is created" — it stood up a real Kubernetes cluster, named after the app it was about to build.
• "the namespace is provisioning" — backing services composing: postgres, auth, routing.
• "Both background tasks… will notify when there's progress" — it spawned its own watchers. It isn't polling and it isn't asking me to look. It set up a pager for itself.
• "I'll verify the UI and deploy as soon as the app answers" — it committed to a verification gate before the deploy. Nobody told it to. It knows a deploy it hasn't verified isn't done.

That's not an autocomplete with delusions of grandeur. That's an operator on shift.

Interactive was the training wheels

Why did we ever sit and watch agents work? Two reasons, honestly: we didn't trust them, and — the deeper one — they had no way to check their own work, so we were the verification step. Every "does that look right to you?" is an agent outsourcing its missing feedback loop to your eyeballs.

An interactive session is a conversation. -p is a delegation. And you can only delegate to someone who can verify their own results — otherwise you're not delegating, you're just watching from further away.

So the interesting question isn't "how did the model get good enough to run headless?" The models have been able to type kilter up for a while. The question is: what made the environment verifiable enough that unattended became safe?

The substrate is doing the heavy lifting

Walk through what the one-shot actually needed, and notice how little of it is model intelligence:

• One verb per outcome. kilter init, kilter up, kilter deploy — each does a whole, coherent thing and reports structured status. The agent composes three verbs, not three hundred YAML decisions.
• Health as a first-class signal. The app declares a health endpoint; the platform watches it; the agent subscribes to the outcome. "As soon as the app answers" is a real, machine-checkable condition — not vibes.
• Dev against the runtime infrastructure. The cluster the agent verified on is made of the same primitives production runs. So its local green light means something — there's no "works in the sandbox, dies on the host" seam for the one-shot to fall into.
• Reconcilers own the aftermath. Once deployed, desired state is enforced by the platform, not by the agent staying awake. The agent can exit. The system keeps being correct.

This is simple-not-easy paying rent. An agent has infinite patience for effort, but headless operation has zero tolerance for incoherence — there's no human in the loop to paper over a leaky abstraction. -p works precisely to the degree the surface underneath is read-edit-verify all the way down.

What my workflow actually looks like now

Interactive Claude is where design happens — architecture arguments, taste, tradeoffs, the conversation. But execution-shaped work has been quietly migrating to one-shots:

claude -p is turning into what make used to be: the thing you type when you already know what done looks like. Some of these don't even start from my keyboard anymore — they're fired by CI, by a schedule, by another agent. The terminal session is quietly becoming a cron job.

And this is the inner-enterprise loop at its logical end: when standing up a governed, disposable environment is a one-shot, the number of small, purposeful systems a team runs stops being limited by anyone's attention span.

The honest caveats

One-shots fail. When the task is underspecified, when the repo is weird, when the surface gets muddy, the delegation degrades — and I drop back into an interactive session to sort it out. The ratio shifts every month, but it isn't 100% and I'm not pretending otherwise.

And unattended means governed, not unaccountable. The agent runs as a real principal — attributed, audited, bounded by the same RBAC and policies as everyone else. "Nobody was watching" is only an acceptable sentence because the audit trail was.

The punchline

The demo everyone builds is an agent writing code. The thing that actually changed my week is an agent finishing — cluster, services, build, verify, deploy — with me not in the room. Code generation made software cheap. A verifiable substrate is what makes it done.

kanban42 is running, by the way. The sandwich was also good.

Update, the next morning: it was not running. The one-shot had died politely in the background — taking its watchers with it — and the app namespace had zero pods. The post-mortem, and the seven fixes that made the second shot actually land, is One Prompt, Zero Hands. Everything above about delegation and verifiable substrates survives the correction — sharpened, in fact. The sandwich holds up too.

Where to go next

1. Read Part 2: One Prompt, Zero Hands — the post-mortem of this exact run, and the recipe that made it real.
2. See what makes a platform agent-native — the read-edit-verify loop that makes unattended safe.
3. Read The k8gentic Revolution — why agents need simple, not easy.
4. Read Infrastructure Is the Product — where the one-shot's output goes to live.
5. Start your free trial and try the one-shot yourself.