The demo lands, the agent writes code in real time, and someone in the room says the quiet part out loud: if the software can be built this fast, why does everything around it still take weeks? The pull request opens before the sales call ends. The invoice for that same work clears a month later.
That mismatch is the story of agent-assisted software delivery right now. Typing sped up while reviewing, deploying, approving, and paying stayed on their old schedule. If you're commissioning custom software and wondering why the speed you saw in the demo keeps disappearing somewhere between the merge and the money, the answer is less about the model and more about the pipeline it lives inside.
The Demo Is Honest. The Production Pipeline Is the Catch
Vendors aren't lying when the demo runs fast. An agentic coding assistant can genuinely pick up a ticket, draft a plan, write a branch, and open a pull request while the sales engineer narrates. That's new, and it's real. Programming Insider makes the case for why AI coding agents shift the bottleneck to code review rather than removing it. The PR is now the unit of work, and the merge button is the deadline.
A demo environment also skips the parts of delivery that still take humans. No security review. No staging environment with real data. No change-management ticket, no compliance sign-off, no AP clerk waiting on a PO number before a payment can be released.
Analysts have been pointing out for a while that exhaustive feature walkthroughs create a buying experience that doesn't match what deployment feels like. Same story now for AI-assisted builds: the live keystrokes look fast because everything around them has been stripped out of the room.
Why 'Just Ship Faster' Doesn't Fix It
The intuitive response is to push the vendor to move at demo speed in production. Open more PRs. Merge sooner. Get invoices out and paid on the same cadence the agent writes code.
It doesn't work, and it's worth understanding why before you try. Three things resist that pressure, and none of them are solved by a smarter model:
- Review capacity is fixed. A senior engineer can only meaningfully review so many diffs in a day. When the agent opens five PRs an hour, the queue grows faster than humans can read it. Volume shipped is not the same as value shipped, and skimming a diff to keep up is how real defects slip into main.
- CI and tests become the gate. If your pipeline takes 40 minutes to run, that's your real cycle time per change, not the two minutes the agent took to write the branch. Flaky tests, slow integration suites, and manual QA steps turn into the actual bottleneck the moment code generation stops being one.
- Payment and procurement run on their own clock. Invoice processing in manual AP teams runs 10 to 20 days, and complex approval chains stretch that to several weeks. No model changes how long it takes your controller to route a bill through three signers.
Push harder on any of these and you don't get faster delivery. You get merged bugs, failed deployments, and a vendor relationship where everyone is annoyed about money.
What Actually Works for Teams Commissioning Custom Software
The teams getting real value from agent-assisted delivery are the ones who moved their attention up a level. They stopped buying lines of code and started buying the review-and-release process around them. A few shifts tend to show up:
- Ask about the review queue, not the model. It matters less which assistant the vendor uses than how PRs get reviewed, who signs off, and how long diffs sit before merge. If the vendor can't describe their review SLA, the agent's speed is theoretical.
- Price the pipeline, not the feature. A sensible contract covers CI minutes, test maintenance, staging environments, and rollback plans, not just the hours an engineer spent at a keyboard. Those are the costs that scale when an agent is in the loop.
- Define 'done' before you accept volume as progress. Merged into main is not done. Deployed, observed in production, and backed by a test that will catch the next regression is closer. Write that into the statement of work.
- Fix your side of the clock too. If you want a vendor to deliver in two-week cycles, your AP process can't take five weeks to pay the invoice that closes the cycle. Pre-approve POs, cut the signer count where you can, and let the vendor invoice on a milestone they control.
The Real Takeaway for Buyers
Agentic coding assistants have made the typing part of software delivery genuinely fast. They haven't sped up judgment, security review, deployment risk, or your accounts payable department. Those were the slow parts before, and they're a bigger share of the total time now, not a smaller one.
When your next vendor demo runs at a pace that feels like magic, enjoy it. Then ask the questions the demo doesn't answer: who reviews the PRs, how long does CI take, what counts as done, and how fast can your own team pay for the work. An invoice taking weeks to clear isn't the vendor's fault, or yours. It's a signal that the rest of the system hasn't caught up with the code, and until it does, that's where the speed you were promised will keep leaking out.