{unscripted} Chicago & Columbus recap: the bottleneck moved. Did your controls? | Harness Blog

Chicago and Columbus (and more more cities) in one week, and I keep coming back to the same thought. A year ago on these stages, we talked about how AI would change software engineering. This year there was nothing left to predict. Every team, every developer, every day. So the conversations in Chicago and Columbus weren't "should we use AI?" It was "why isn't all this code turning into value?" Here's my recap, plus where to catch the show next.

Code is infinite. Risk isn't.

Jyoti Bansal opened Chicago with the stat that framed the events as a whole. Developers using AI are producing about 180% more code, but only about 30% more is actually shipping. In Columbus, Trevor Stuart put it even more bluntly: for every dollar you spend on AI coding, roughly 30 cents makes it to production.

The reason is simple. We funded the left side of the SDLC and starved the right. Everything after the PR still waits on a person: manual reviews, scripted pipelines, weekly change advisory boards, and vulnerability spreadsheets bouncing between teams.

And no, the answer isn't waiting for AI to write perfect code. Nobody writes perfect code. I've been writing it a long time, and I don't. We're just producing imperfect code an order of magnitude faster than ever. That's exactly why controls exist, and why skipping them is the worst option on the table.

The keynotes in both cities laid out what the alternative looks like:

• Risk-based autonomy. Trevor used a Tesla analogy. You don't buy one and flip straight to Mad Max mode. Agents can run deterministic golden paths, make decisions with a human approving, or run fully autonomously inside your guardrails. You choose per application, environment, and task.
• Change Advisor replaces the CAB meeting. It gathers the evidence a CAB would ask for and scores the risk. High-scoring changes go straight to production. Anything below your threshold waits for a human. Judging by the photos in Columbus, nobody likes CABs.
• Worker agents do the toil, fully governed. In Chicago, an agent caught a failed build, found the missing dependency, opened the PR, and reran the pipeline. It used the same RBAC, policies, and audit trail as any other step.
• Policy earlier, not policy for policy's sake. In the Software Factory preview, a spec failed its design gate because an agent was about to rebuild a payments platform that already existed. Would you let me build a separate runway for every airplane at an airport? Then don't let an agent do it to your architecture.

Nobody gets to say no anymore

I moderated a Chicago panel with a platform engineering leader from a financial services company and the CTO of a global professional services firm. It turned into one of the more honest conversations I've had on stage.

• AI is a magnifying glass. One panelist cited research showing developers feel about 20% faster with AI, but can end up about 19% slower once rework is counted. That's a 39-point spread. We assumed coding was the bottleneck. Was coding ever the slowest part of your delivery before AI? Yet it's what we attacked first.
• Raw materials don't make trucks. Pile raw aluminum in front of an F-150 plant and you don't get more F-150s. Pile raw code in front of pipelines you haven't changed and you get exactly what you got before. The teams winning now are the ones that put in the guardrails and easy paths to production years ago.
• Give people a safe place to fail. Yes, I did a Mario analogy. World 1-1 is where you learn to handle the turtle shell. Production is at Bowser's castle. Build levels where falling in the pit is survivable.
• Security can't say no. Governance can't say no. Risk can't say no. If we're going to work at machine speed, every team has to publish its rules as a path to yes. I've said versions of this for years: make it easy to do the right thing and hard to do the wrong thing.
• Single-player vs. multiplayer. One company rolled out an AI usage leaderboard, and it turned into what the team called the "AI Hunger Games": people burning tokens to climb the board. The teams furthest along are learning to use AI to lift everyone up together.

Compliance is a feature, not a brake

Columbus had a governance panel that I wish every compliance team could have watched:

• Engineer compliance like a feature. A delivery acceleration leader at a regional bank argued that when you design compliance to fit how you ship software, you stop trading speed for safety.
• The law of conservation of risk. From the same leader: risk can't be created or destroyed, only change forms. I'm stealing that one.
• Downforce, not brakes. The spoiler on an F1 car isn't there to slow you down. It pushes the car into the track so you can take corners faster. That's what good governance does.
• Beware compliance theater. One partner's hot take was that writing an AI usage policy makes teams feel better, but most still can't see what their agents actually call in production. It's not a policy problem. It's an implementation problem.
• Speed without quality is an expensive failure. A technology leader in healthcare added that bolting AI onto an existing process gets you an expensive way to fail. The return comes from rethinking the process end to end.

Another delivery leader offered the best analogy of the day for trusting agents. How do you know an offshore team halfway around the world is building software the right way? Mostly, you don't. So the controls have to be baked into the process itself, no matter who or what is doing the work.

Security at agent speed

The security conversations in both cities kept returning to the same gap. In Chicago, Jyoti noted that attackers can exploit a new vulnerability in under six hours, while it takes about 55 days on average to fix one. That gap is the whole ballgame.

• Security has been automated longer than you think. A retail security leader in Columbus pointed out that his team processes well over a billion security events a day with no human in the loop. Letting machines handle volume isn't new to them.
• Agents break your fraud signals. When an AI agent shops on a customer's behalf, the signals retailers rely on drop from around 60 to a handful. Geography and IP reputation just look like a big AI provider.
• There's a black market for your tokens. A Chicago panelist described marketplaces where bad actors bid on stolen AI provider API keys so they never pay for their own tokens.
• Reachability ends the argument. If you can prove a vulnerability isn't reachable, the week-long debate between security and development disappears. Fix the net-new criticals that matter and move on.

The hidden cost of machine speed

The closing panel in Columbus got into what nobody puts on a dashboard, and it hit hard:

• PR size is the new bottleneck. A developer experience leader at a century-old insurer explained that 300-line changes are now trivial to generate. But only one or two senior engineers per repo can confidently review them, and those people are burning out.
• Change confidence is falling. More frequent releases used to mean higher confidence. Now releases are more frequent while confidence in each change goes down. That's not a testing problem. It's a change confidence problem.
• Kill the release window. One platform leader's team canceled monthly and quarterly releases entirely. No more 3 a.m. calls with "50 of their closest friends," and their incident metrics are the best they've ever had.
• Build it and they still might not come. Even with the capability in place, teams stick to what's comfortable. You have to show them the way, not sell it to them.
• The data on CABs is in. One panelist pointed to research showing teams with rigid change advisory boards can have lower quality than teams with none. Risk scoring based on real signals beats subjective approval.

What's coming this week and next

{unscripted} 2026 is in the home stretch, and there's still time to join us:

• Atlanta: Tuesday, September 29
• Virtual {unscripted}: Wednesday, September 30

If Chicago and Columbus are any indication, bring your hardest questions. How much autonomy should agents get? How do you keep security in the loop instead of behind it? How do you scale review as fast as generation? You know I've got opinions – what are yours?

‍