Part 3 of a series on engineering discipline in AI-assisted development, originally published on LinkedIn — Parts 1 and 2 are linked at the end.

TL;DR — AI made code generation cheap, but the output is non-deterministic and shaped by the vendor's guardrails, not your organization's standards. What turns it into an asset is a harness: those standards injected into every phase of the lifecycle, with gates that check the shape held. Not determinism from the model. Determinism by constraint, checked by gates.

Over the last few months, I have had the same conversation with a lot of IT managers and engineers. AI coding is no longer an option in their organizations; it is the standard. And the question they all ask me is the same one:

"How do you use AI for coding?"

I answer with a question.

"Hold on. Does your organization have defined development standards — a document, a wiki? Training materials that a new engineer actually goes through during onboarding?"

Most conversations stall right there. That stall is the whole story of this article.

What Standards Were Always For

Standards were never bureaucracy for its own sake.

An organization keeps coding standards, architecture standards, CI/CD standards, pinned compiler versions, and deployment standards so that quality does not depend on one engineer's exceptional ability. Skilled or unskilled, the baseline holds. A standard guarantees the floor. Talent still raises the ceiling. Anyone can approach the output, understand it, and continue it. That is not red tape. It is the software industry's oldest aspiration, and the product of decades of hard experience.

It also has a name. The Software Factory is a concept from half a century ago. Manufacturing got its conveyor belt more than a century ago; software has been trying to build its own factory ever since — and failing at the same joint every time. The line could be drawn, but the worker standing on it was human. Humans interpret standards. They skip steps when the deadline bites. The best of them outgrow the line and improvise around it.

The concept was never wrong. A part was missing: a worker who reads the standard completely, literally, and identically every single time. That worker has now arrived. It is the agent.

In Part 1, I called all of this process. The word the industry has settled on since is harness. Keep the word in mind. The rest of this article is about what a harness has to be.

The Flood

Since I wrote Part 1 of this series in March, the frontier models have leapt forward again and again. My feed is full of posts that begin "Look at this — I built this software alone, in a day." Vendors now sell agent-based development environments with no code editor at all, each one promising to lower the threshold of software engineering a little further.

I am not standing outside this flood. I cannot imagine coding without AI anymore.

Is it a revolution in software engineering? In one specific sense, honestly, yes: the cost of producing a first working version has collapsed. That is historic, and it is real.

But notice the sequel nobody posts. Not "six months in production." Not "it survived its first incident." Not "a second engineer joined and took it over." The hard part of software engineering was never producing the first version. It is changing it, keeping it alive, and handing it over.

Why I Look at This Cynically

The flood leaves something out. AI is fundamentally non-deterministic.

Yes, every vendor ships guardrails, and agents produce code on top of them. But a vendor's guardrail guards the vendor's risks: safety, policy, liability. It is not your organization's standard. Run the same request tomorrow and you get a differently shaped system. And code that arrives shaped by nothing in particular has to be judged from zero, every time, by whoever reviews it.

The numbers have started to say this out loud. In LinearB's 2026 Software Engineering Benchmarks (over eight million pull requests), AI-authored PRs were merged within 30 days only 32.7% of the time, against 84.4% for manual PRs. Production exploded; acceptance did not follow.

Ask why, and the honest answer has more than one part. Plenty of AI pull requests are experiments, and plenty arrive with no human owner to carry them through review. Take those explanations seriously. Then notice what they have in common: neither one is a model failure. Both are what happens when code lands in an organization that has no defined process ready to receive it. The models are not weak; they are giants. It is the receiving end that is missing.

So I keep coming back to one question: can that code become an asset of your organization?

An asset has to be reproducible. It has to be maintainable by someone other than its maker, including a future agent. It has to make the next project cheaper than the last one. Unpinned generation is none of the three. It is output, not accumulation. And technical debt produced at machine speed is still technical debt.

Every road in this conversation returns to my first question: does your organization have development standards?

What a Harness Actually Has to Do

If the giant is non-deterministic, you do not fix the giant. You narrow the room it works in, and you keep what it learns.

That is what a harness is for, and it has two jobs.

First, injection. The organization's standards and processes have to be put into the harness faithfully and completely, because a standard that is half-injected is half-followed. Concretely, that means templating the entire SDLC lifecycle: by language, by purpose (API, CLI, web), by architecture, by hosting environment, cloud and on-premises, through CI/CD and DevOps. The organization's own experience is melted into those standard templates, the giant's output is forced into the same shape every time, and gates verify that the shape held.

Not determinism from the model. Determinism by constraint, checked by gates.

Second, sharing. The harness is where the giant and the human engineers share experience. What the humans learn in the field gets encoded back in — as skills, checklists, and patterns. What the giant produces is left behind as records the humans can read, question, and audit. One run's failure becomes the next run's standing knowledge instead of evaporating when the session ends.

Put those two together and you finally get the thing the Software Factory was always reaching for: a conveyor belt that is the organization's own, one that enforces productivity, consistency, and quality management through standards, and that belongs to the organization because its experience is what is baked into it.

So I Built the Next One

Part 1 argued for the process. Part 2 showed a 15-skill system I built for one job (Kubernetes migration) and ended with an admission: clear patterns for making agents check each other's work were still missing. The obvious next step was to generalize the system, and to build those missing patterns into the lifecycle itself.

So I designed a harness that templates the processes of the standard SDLC lifecycle end to end, built so that an organization can inject its own experience and standards and customize them. It is called SDLC Harness, and it is open source. Ten phases from intake to retrospective. Specialized agents and reusable skills for each phase. A QA panel that scores the work against explicit gates and sends it back when a domain falls below the line. Mechanical checks that fire while code is being written, not after. And records (a project manifest, a failure ledger, a pattern register) whose only job is to carry what one run learned into the next. The coverage is deliberately broad, across stacks, project types, and hosting targets, because a belt that fits only one factory is a demo, not a belt.


One run looping the phase ring: the QA panel scores the work, a domain below the gate sends it back to Build, the fix passes a second test round, and the re-check passes.

That loop is not a metaphor. Run a system end to end and watch where the work actually stops. It is almost never the model writing code. It stops at the seams: a configuration that disagrees with the code it is supposed to run, a platform default that quietly closes a path the design assumed was open, an instruction that a safety filter refuses and nobody thought twice about. None of these appear in demo videos. Each one surfaces only because a phase exists whose job is to look for it. The work goes back, gets fixed, and gets checked again, instead of shipping with the seam torn. The generation takes minutes. That loop is where the engineering lives.

I am not telling you this because my harness is the answer. The code is here: https://github.com/Dongbumlee/sdlc-harness — fork it, break it, argue with it. That was the invitation in Part 2 and it still stands. The harness is one attempt. The point of this article is not the attempt.

Don't Miss the Part That Matters

The tools will keep coming. The ideas will keep coming. The models will keep getting stronger, and engineers will keep screaming with joy — happily, and I am one of them.

Just don't miss it.

Newton said we stand on the shoulders of giants. The giants are here now, and the thrill of standing up there is real. But nobody climbs a giant with bare hands and good intentions. You climb with a harness: the gear that lets you get up, stay up, and work once you are there.

And the harness only holds if it is built from your organization's own standards, ready before the giant starts writing.

Because code from a giant, produced without your organization's standards in place, has nowhere to go but garbage.

So let me ask you the question I ask every manager and engineer who asks me how:

Does your organization have development standards — written down where your new hires, and your giants, can read them?

Part 1: "Stop Vibe Coding. Start Engineering With AI" — https://www.linkedin.com/pulse/stop-vibe-coding-start-engineering-ai-dongbum-db-lee-5s9qc/
Part 2: "I Built a 15-Skill AI System for K8s Migration. What No One Tells You About Multi-Agent Engineering." — https://www.linkedin.com/pulse/i-built-15-skill-ai-system-k8s-migration-what-one-tells-lee-6mcic/
SDLC Harness (open source): https://github.com/Dongbumlee/sdlc-harness