There are two ways to be wrong about a power tool.
The first is to think it's magic. You wave it at the wood and trust that beautiful furniture will emerge. The second is to think it's possessed. You won't go near it, you whisper about it in meetings, and you forbid anyone else from touching it until "we understand the risks."
Both people end up with no furniture. One because the table collapsed, the other because the table was never built. The carpenter, the actual professional, does neither. The carpenter knows precisely what the tool does, what it doesn't do, and where to keep his fingers.
That's this essay. Not the mathematics of how AI works, you don't need to understand combustion to drive, but the behavior. Because you cannot govern a machine you've mistaken for either a wizard or a demon.
An agent that can approve its own work isn't an employee. It's an accident with a résumé.
What the machine actually is
Let me strip away the mystique, because the mystique is where the bad decisions live.
The Magic Intern from Part 1 is not thinking. It is producing extraordinarily well-informed guesses about what comes next, one piece at a time, based on a staggering amount of reading. That's it. That's the trick. It is the most confident pattern-matcher ever built.
This explains everything you've seen it do, the good and the alarming:
It's brilliant at things that look like things it's seen before and most software does. That's the good news, and it's enormous.
It has no idea what's true. It has an idea what's plausible. Most of the time those overlap. The danger lives entirely in the gap.
When it doesn't know, it does not stop and frown. It produces a confident, fluent, completely fabricated answer in exactly the same tone as a correct one. We call this "hallucination," which makes it sound charming. It is not charming when it invents a regulation.
It remembers nothing on its own. Every conversation starts from zero unless you hand it the context. (Remember Part 2's shared record? This is why that solid ground isn't a nice-to-have. It's how the intern stops being an amnesiac.)
None of this is a flaw to be fixed. It's the nature of the thing. You don't fix a circular saw for being sharp. You respect that it's sharp and you build a guard around it.
The leash is the whole point
Here's the line GSD will die on, and it's the spine of how we build: human-governed, not fully autonomous.
I want to be precise, because "autonomous" is the word the whole industry is in love with, and it's selling you a fantasy. An autonomous agent is one you set loose to make consequential decisions on its own. A governed one drafts, proposes, and executes the work, but every decision that actually matters passes through a human hand.
The difference is the difference between a brilliant junior employee and an unsupervised one. Nobody sane wants the second. The fantasy of "fire-and-forget AI that runs your company" isn't a productivity feature. It's an unsigned liability waiting for a court date.
So at GSD, the machine wears a leash by design and the leash isn't a sticky note that says "please be careful." It's built into how the work flows. The agent can do enormous amounts. What it cannot do is decide it's finished and ship. That signature is reserved for a person, permanently, on purpose.
Many small specialists beat one giant genius
Now, a practical point that separates shops that get value from AI and shops that get incidents.
The instinct is to build one enormous, all-knowing agent. The "do everything" robot. This is a mistake, and it's the same mistake as hiring one person to be your architect, your plumber, your electrician, and your inspector. You don't want a generalist with godlike confidence and no specialty. You want a crew.
So GSD runs a catalog of specialists, each with a narrow job and a name. One agent's entire life is clustering messy input into themes. Another's is drafting objectives. Another models the domain. Another designs components, another writes tests, another reviews the work. Each one does a single thing, produces a single clear result, and hands it on.
Above them sit the orchestrators: the foremen. They don't do the trade work; they coordinate it, decide what happens next, route the work back when a phase needs rework, and keep the whole job moving in order.
We give them callsigns, by the way: the foreman, the pathfinder, and so on. Partly because it's clearer in the logs. Mostly because a crew with names is a crew you can actually reason about, instead of a fog labeled "the AI."
Why does this matter to you, the person paying for it? Two reasons. A specialist with a narrow job is checkable. You can look at one clean output and know if it's wrong, instead of auditing a mystery. And a specialist is cheap. You don't need your most expensive, most powerful model to sort items into buckets. You need it for the hard reasoning, and a humbler one for the rest. (Hold that thought. It's most of Part 4.)
Who holds the lifecycle
One more idea, because it's the quiet architectural decision that makes the whole thing trustworthy, and I'll keep it tool-agnostic.
There's a difference between the long story of a piece of work, proposed on Monday, gated Tuesday, built Wednesday, reviewed Thursday, sometimes sent back, finally shipped next week, and the short burst of reasoning an agent does in a single sitting.
The mistake is to let the machine own the long story. To let the AI be the thing that remembers where everything is and what state it's in. That's how you end up trusting a confident amnesiac with your project's official status.
GSD's rule: the system of record owns the lifecycle; the machine only owns the thinking inside one step. The official truth of where things stand lives in something durable, governed, and auditable, not in the head of a model that forgets the moment the session ends. The agent is a brilliant temp worker who comes in, does a focused job, and goes home. The building's permanent records do not live in the temp worker's memory. They live in the building.
That one decision is the difference between AI as a trustworthy crew member and AI as the new single point of failure nobody can interrogate.
A guard rail, not a blindfold
Notice what we've actually built here. Not a blindfold, we're not afraid of the tool. Not a blank check, we're not worshipping it. A guard. The machine runs at full speed inside a frame that makes its work checkable, its decisions human-signed, and its memory borrowed from a source of truth that doesn't lie to itself.
That's what "knowing your machine" buys you: the confidence to let it move fast, because you've engineered exactly where it can't go.
So here's your self-diagnosis. Walk over to wherever AI touches your delivery today and ask one question: Can it decide it's done and push, with no human signature in the path?
If the honest answer is "well… sort of, in a few places, if we're being truthful", you don't have a crew. You have an unsupervised intern with production access, and you've simply been lucky. Whether that leash actually exists, or just exists in the slide deck, is one of the sharpest things GSD's Maturity Assessment goes looking for.
Respect the saw. Build the guard. Then, by all means, let it rip.
Measure twice, prompt once.
Next in the series — Part 4: "The Bill Always Comes Due — What Your AI Actually Costs."
*Not sure whether your AI runs on a leash or on luck? GSD's Maturity Assessment takes a structured, behavior-driven look at how your delivery org actually governs the machine.*
Back to Blog