AI-assisted delivery is an orchestration problem, not a code problem

Every month someone asks how we ship a working application in days instead of quarters. They expect the answer to be a specific model, or a prompt library, or a secret agent framework. It isn't. The code generation part is the least interesting thing we do.

Google's 2025 DORA report, summarized well by Aviator, puts numbers to something we've felt for a while: AI amplifies whatever delivery system you already have. Teams with strong platform engineering, test coverage, and trunk-based practices see throughput jump. Teams without those get faster at breaking production. Same tools. Opposite outcomes.

That gap is the whole game.

What actually eats the days

When we quote a timeline on something like a cavity-pressure monitoring app or a scrap-tracking tool over an existing historian, the code is maybe 20% of the clock. The rest looks like this:

- Pulling tag dictionaries out of a SCADA or MES and figuring out what's actually populated versus what's labeled. - Standing up environments, secrets, auth, logging, and backups so the thing survives contact with a plant network. - Writing enough tests that an agent-generated change doesn't quietly flip a sign on a calculation. - Review gates where a human reads the diff before it touches anything a planner or operator depends on.

None of that is glamorous. All of it determines whether you ship in a week or spend three months in integration purgatory.

Agents in a pipeline, not a chat window

The LangChain team has a good writeup on agentic engineering that mirrors how we work. The useful mental model isn't a developer with a smarter autocomplete. It's a small pipeline of coordinated agents: one plans against a spec, one implements, one reviews, one writes and runs tests, one handles deployment. They work in parallel on different slices. Humans sit at specific checkpoints.

This only works if the scaffolding is already there. Managed infrastructure, opinionated project templates, a CI pipeline that will actually fail a bad PR, observability that tells you when a nightly job stopped firing. Without those, more agents means more mess, faster.

Where we keep humans in the loop

Three places, consistently:

1. Spec and acceptance criteria. An agent will happily build the wrong thing on time and under budget. Someone who's walked the line writes the spec. 2. Code review on anything touching data writes, control logic, or money. Reads are cheaper to be wrong about. Writes aren't. 3. Production cutover. Promotion to prod is a decision, not a cron job. We've gotten burned enough times to keep it that way.

For everything in between — boilerplate, migrations, test harnesses, dashboards, API glue, documentation — agents do most of the typing and we do most of the thinking.

The honest version

"AI-powered delivery" is a boring sentence once you look under it. It's good orchestration, decent platform work, strict QA on the parts that matter, and the discipline to keep humans where humans still beat agents. Forrester's analysts have been making a similar point: the shift is from code assistants to orchestrated SDLC agents, and the winners are the ones who built the plumbing first.

If you already run a tight shop, AI will make you faster. If you don't, it'll make you faster at the wrong things. That's true for software, and it's true for the plants we build software for.