A golden path is the supported way to do something. The blessed route from empty repository to running service: the approved language, the standard pipeline, the logging that already works, the security controls you get for free if you stay on the road. Spotify popularised the term; most platform teams have some version of it now, whether or not they call it that.

Golden paths were designed for a specific traveller: a human developer. Someone who reads the wiki, copies the template, notices when something looks off, and fills the gaps with judgment the documentation never spelled out.

That traveller is no longer the only one on the road.

Coding agents now do the things golden paths were built to guide. They scaffold services, open pull requests, wire up pipelines, follow the setup steps. And they do it without the thing every golden path quietly relies on: a human who can infer what the page did not say.

This is when the consumer is a machine, pointed at platform engineering. The golden path is becoming an interface consumed by software, and most golden paths were never built to be one.

What a golden path actually is today

Pull apart a typical golden path and most of it is written for human inference.

A README that explains the "usual" setup. A template repository you copy and then edit by hand. A wiki page with the steps, some marked "optional" with no rule for when. A Slack channel where you ask the question the docs did not answer. A senior engineer who reviews the result and catches the thing that was technically followed but obviously wrong.

This works because humans are good at the unwritten part. We read "configure logging" and know it means the standard logging, in the standard format, shipped to the standard place, because we have seen it before or we can go and ask. The path is a set of hints, and the human supplies the rest.

A machine does not supply the rest. It does exactly what the path says, including the parts the path did not think it had to say.

Where the human path breaks for a machine

An agent following a human golden path fails in a particular way. Not loudly. Quietly, by doing something plausible.

It picks a logging library, because the docs said "add logging" and not which one. It skips the step marked optional, because nothing told it the step is only optional for internal tools. It satisfies the letter of the template and misses the convention that lived in the reviewer's head. Every one of these is the model filling a gap, which is fine when the gap is small and dangerous when the gap is where the engineering lived. I made that argument about vibe coding; the golden path is where it stops being abstract.

The problem is not that the agent is careless. The problem is that the path was written in a language with a human-shaped hole in the middle, and the machine cannot see the hole, let alone fill it.

What a golden path for machines looks like

If the consumer is a machine, the path has to stop being a recommendation and start being an interface. Same intent, different substance.

Standards that are machine-readable, not prose. "We use structured JSON logging" on a wiki is a hint. The same rule as a schema, a linter, and a policy check that fails the build is an instruction a machine can follow. The convention has to move out of the sentence and into something executable.

Templates that are scaffolds, not snippets. A copy-paste block assumes a human will adapt it. A real scaffold, the kind Backstage software templates generate, produces a correct starting point from parameters, with the choices already made. The agent fills in values, not architecture.

Contracts for the things the path touches. When the path says "call the payments service" or "use the secrets store", a machine needs the actual interface: the inputs, the outputs, the errors, what is allowed. A contract is a door an agent can walk through without guessing. A wiki link is not.

Evaluation hooks along the path. Spotify paired its golden paths with a "golden state", a set of checks that tell an engineer whether their system is still on the path. Humans can treat that as optional. Machines cannot. The checks have to run as the agent works, not just at the end: does this meet the standard, clear the threshold, break a policy? The path has to give feedback, because the traveller can no longer judge its own work.

Audit trails as a default output. When a human walks the path, the trail is implicit in the commits and the review. When an agent walks it, you want the path itself to emit a record of what was done, with what inputs, under what approval. Not reconstructed later. Produced as you go. This is the oversight argument from "human in the loop is not a strategy": oversight is something the system produces, not something a signature asserts.

A safe place to act. A human on the golden path can be trusted with some blast radius. An agent should earn it. The path needs a sandbox: somewhere the machine can run, fail, and be corrected without touching anything that matters until the evidence says it should.

The path stops being a suggestion

Notice what these have in common. A human golden path optimises for being easy to follow. A machine golden path optimises for being hard to leave without anyone noticing.

For people, the rails are advisory. You can step off the paved road, and sometimes you should, and a good platform lets you. For a machine, advisory rails are no rails at all. The path has to be the thing that actually runs, with deviations detected rather than hoped against. It becomes less like a tutorial and more like an API: typed, versioned, validated, and unforgiving about inputs it does not understand.

That sounds restrictive. It is the opposite. The point of a golden path was always to make the safe thing the easy thing. A machine-legible path does exactly that, more reliably than the human version ever managed, because it no longer depends on the traveller having good taste.

Build it for the machine and the human wins too

Here is the part that makes this worth doing now rather than when you are forced to.

A golden path you rebuild for machines is a better path for people. Executable standards beat a wiki nobody reads. A real scaffold beats a stale template. Contracts beat tribal knowledge about which service to call. Evaluation hooks beat finding out in review. The work that makes the path legible to an agent is the same work that makes it legible to the new hire, the tired engineer at 3am, and the team that inherits the service two years from now.

This is the recurring shape of AI and delivery. The machine does not invent a new requirement so much as it removes your ability to skip an old one. DORA's 2025 report keeps landing on the same point: AI amplifies the system it runs inside. A clear golden path gets clearer under agents. A vague one industrialises its own vagueness.

The reframe

Golden paths were a good idea built on a quiet assumption: that a person was walking them, and a person could be trusted to fill in what the path left out.

That assumption is expiring. The next traveller reads literally, infers nothing, and acts at speed. It will follow your path exactly as written, which means the gaps you have been getting away with are about to become visible, in production, at scale.

The fix is not to keep agents off the golden path. It is to build a path worth giving them: machine-readable, contracted, evaluated, audited, sandboxed. Designed, finally, for a traveller who cannot read between the lines and will not pretend to.

Build the path for the machine. The humans were tired of reading between the lines anyway.