As AI coding agents move beyond autocomplete to autonomous software development, Jason Beres, COO, Infragistics, examines why CIOs must rethink engineering workflows, accountability, security and talent development.
Copilot-style tools changed how code gets written, resulting in a shift from autocomplete to autonomy.
A Reveal survey of IT and engineering leaders earlier this year put a number on what most engineering organizations already knew: 80% had already used AI in software development in 2025 and 77% named expanding AI a top priority for 2026.
But what most CIOs haven’t fully grappled with yet is the wave coming after Copilot-style tools, and it doesn’t look anything like the first one.
A Copilot-style assistant suggests the next line of code and waits for someone to accept it, reject it or rewrite it. A coding agent reads a ticket, plans an approach, makes changes across a dozen files, runs the test suite, fixes what breaks and opens a pull request for review, often with nobody watching in real time.
That’s a suggestion engine turning into something closer to a teammate. And if you’re governing it the same way you governed autocomplete, you’re going to find out the hard way that those are two very different jobs.
Autocomplete was the easy part
Copilot-era tools were genuinely useful for boilerplate, for jogging a developer’s memory on syntax they hadn’t touched in months and for closing gaps outside someone’s core expertise. But there was always a human in the loop who had the last word on what actually shipped.
Agents don’t work that way. They run in long-running execution loops, sessions that go for minutes or hours (or even days) without a person checking in on every step. They also carry memory between sessions, usually through a config file sitting in the repo that spells out a project’s architecture once instead of someone re-explaining it every time.
Memory, not the prompt, is becoming the real interface between engineers and the work getting done for them.
That’s a different working relationship than the one Copilot trained everyone on, which is exactly why you can’t just bolt agent adoption onto whatever governance you already had in place. The workflow needs to be rebuilt, not patched.
What CIOs actually need to design
Among the CIOs and engineering leaders getting engineering workflows right, the same four questions keep coming up.
Who owns what the agent does? Every action an agent takes needs to trace back to a person who signed off on that scope, whether that’s the tech lead who wrote the ticket or the engineer who approved the merge. Accountability is key.
When an agent can call APIs and touch production configuration and rewrite a dozen files in one run, accountability has to be built in from day one, not reconstructed after something breaks.
Nearly six in ten organizations (57%) cite incorporating AI into the development process as their top software challenge and 48% point specifically to security and privacy risk, according to the Reveal 2026 Top Software Development Challenges survey. Those numbers tell you where the next outage or compliance mess is quietly taking shape if nobody’s assigned to own it.
What’s the agent actually allowed to touch? Broad, always-on access felt harmless back when the tool was only suggesting a line of code. It’s not harmless now. Least-privilege access, scoped to exactly what a task requires, has to become the default.
An agent holding production database credentials and a long leash is a fundamentally different risk than a developer with the same access, because the agent moves faster than any human review process was ever built to catch.
How do you keep building a pipeline of senior engineers if agents are doing all the entry-level work? It’s the question discussed least, and it’s the one that should worry CIOs most. Boilerplate, low-complexity bug fixes and documentation are precisely what agents do fastest and cheapest.
The hiring numbers from the 2026 Reveal IT Talent survey show where we are heading: 70% of organizations are prioritizing senior technical hires right now and only 12% are focused on entry-level talent.
The problem will occur when you’ve quietly closed the on-ramp that turned today’s junior developers into tomorrow’s senior ones. CIOs need to build alternative paths for that judgment to develop, because the agents handling this year’s junior work still can’t make next year’s architectural calls.
And how do you actually know if any of its working? Tickets closed and lines shipped were never great measures of engineering health, and an agent that can generate volume on demand makes them even worse.
Track the cycle time, defect rates and real throughput instead, and hold those against whatever productivity story the vendors are telling you.
AI productivity is identified by Reveal survey 2026 data: 66% of tech leaders credit AI with productivity gains but crediting it and measuring it are two different exercises, and organizations need to do both.
Your senior engineers are turning into orchestrators
No role is moving faster than the senior engineer’s. AI engineering roles are already the hardest technical positions to fill, harder than cybersecurity, harder than cloud, cited by 39% of organizations, according to the Reveal survey.
When you can’t hire your way past that, you ask the senior people you already have to cover more ground, and increasingly that means running a small crew of agents instead of writing every line themselves: assigning the work, checking what comes back, stepping in on the architectural calls no agent should make unsupervised.
That’s a real, learnable skill, and it’s not the one that made somebody a great individual contributor two years ago.
Treat it as something that just happens on its own instead of something you train for, and you’ll burn out your best people under the weight of reviewing everything an agent hands them, with none of the structure that would make it manageable.
Speed without guardrails
There’s a temptation to treat governance as friction, as the thing standing between your team and whatever productivity number leadership is chasing this quarter.
The same organizations naming ethics and security as top concerns are, for the most part, the ones pushing hardest to expand AI use in 2026. However, CIOs must understand that speed without guardrails poses additional risks.
The teams still standing two years from now will be the ones who built the guardrails before they scaled, not after their first bad incident.
Redesigning the workflow, not buying a better tool
The first wave of redesigning the workflow was a procurement decision: which assistant, which license, which IDE plugin to use.
The second wave is an operating decision, touching how work gets assigned, who’s accountable when an agent gets something wrong, how junior talent keeps developing once agents absorb the work that used to train them and what you’re actually measuring to know it’s paying off.
New engineering workflows don’t mean agents replacing your engineering team. Nearly three times as many organizations report AI creating jobs as eliminating them, 48% versus 18%, according to the 2026 Reveal IT Talent survey. Get the workflow right, and your team grows.
CIOs who treat coding agents as a slightly faster Copilot will inherit Copilot’s limitations at agent speed. Those willing to rethink how engineering actually runs, deliberately, with governance and career growth designed in from the start rather than bolted on later, are likely to be ahead of the curve in two years.
The tools are going to keep changing regardless of what we do. What you build around them is the part that’s going to make the difference.
