Coding Was the Easy Part

Or: the night I filed an access request to myself.

The plan was small enough to fit in a coffee break. Point my coding agent at my own model endpoint instead of the vendor's default — wire it into the cloud project I'd already built, so every token it spends runs through infrastructure I control. Estimated time: ten minutes.

The code part was ten minutes. The config was clean. The agent booted, announced the right model, the right provider, the right region — and then sat there blinking, refusing to answer a single "hello."

What followed was an evening of walls. Not one of them was code.

The first wall was almost charming. I pasted a command with a friendly note appended to the end, and my shell — which doesn't treat "#" as a comment unless you ask it to — tried to read my note-to-myself as a filename pattern, and gagged. A small, pure lesson in the gap between mentioning a thing and using it. I'd been speaking to the machine in a language it takes literally. Fine. Onward.

The second wall had teeth. Every request came back with a reauthentication error. My own company's security policy, performing exactly as designed, expiring my credentials on a timer and declining to let the agent refresh them. The one identity with keys to the vault was the same identity whose badge gets deactivated every shift. Correct behaviour. Completely in the way.

The third wall is the one I'll keep. Somewhere in the untangling, I realised I had quietly become three people. A work account that owned the project. A personal account my browser happened to be signed into. And a service account — a small robot my own infrastructure-as-code had minted weeks earlier. Each held different powers over the same project. And at one absurd moment, one of me submitted a formal access request to another of me. The justification field, in its entirety, read: "more tokens please." Principal-agent theory is a tidy little abstraction right up until you are, at once, both the principal and the agent, mailing a form to yourself.

The fourth wall was arithmetic. The project held a ration card for the model with exactly zero stamps on it. Here's the part that's easy to miss: it was never a price problem. I was glad to pay per token. It was a quantity cap — a hard ceiling indifferent to how much you're willing to spend. You can wave money at the counter all you like; the shelf is empty by policy, not by economics.

So I filed for more. Denied in two seconds — fast enough that no human was anywhere near it. The reason, once I dug for it: my billing account was still on a free trial, and trial accounts aren't allowed to buy more of a partner model. Fixable. I upgraded to a real, paying account and refiled the exact same request.

It went into review. For about four seconds. Then it came back with the same flat verdict — denied — and the same granted value of zero. I had removed the reason it first gave me, and it refused anyway, because the reason it gave me was never the real one. The real one is quieter and harder to argue with: a new project, a third-party model, no spending history. A stranger at the gate. You don't talk a stranger past a gate — you wait until you've built a history, or you get sponsored in.

Add it up and a pattern falls out. Every wall was administrative substrate: identity, permissions, quotas, billing tiers. None of it was logic. My agent could write the integration in seconds — it could not grant itself a role, raise its own quota, or upgrade a billing account. And neither could I, really, not without a dozen consoles first agreeing with one another about who I am and what I'm allowed to do.

This is the quiet truth about "high-velocity agentic development" that the demos skip. The model is deterministic and fast. The bureaucracy around it is stochastic and slow, and it is precisely where the velocity goes to die. Code is the part you control. The paperwork is the part that controls you — and an agent, for now, is not allowed to sign any of it.

The whole tangle exists because I'm a one-person shop standing on the wrong side of the gate. Credits, cleared trial limits, a project that isn't treated like a stranger — most of tonight simply evaporates once you're inside. So here's my plan, stated plainly: the moment I'm accepted into Google's startup programme, I'm handing all of this to them, gladly. Let the platform own the substrate. I'll keep the ten-minute part.

Because the coding was the easy part. It always is.