Agents are quickly becoming the ones writing our software.
GitHub’s 2026 Octoverse report found that as of September, developers start more than 40% of pull requests with an agent, up from 17% in March.

Developers’ own estimates point the same direction. Sonar’s 2027 State of Code Developer Survey of 1,026 developers and engineering managers found AI now generates or significantly assists an average of 65% of the code they commit, up from 42% a year earlier and reaching in one year what respondents had expected to take two.
Our ability to review and understand that code hasn’t kept pace. In the same survey, 76% say they generate AI code faster than they can verify it, and 53% now spend more time reviewing code than creating it, compared to 18% before adopting AI tools.
Despite that review burden, only 39% completely agree that AI-generated code is always checked before it’s committed, down from 48% a year earlier, even though 94% don’t fully trust it.
42% also say they’re very or extremely concerned that well-written AI code makes bugs harder to spot. That gets at something deeper than review volume, because code can look clean, pass review, and still behave in ways nobody on the team fully understands.
For security, this lands in a familiar place. Every one of those changes ends up in production somewhere, and someone is accountable for deciding whether it was safe to ship, often with far less context than the people (and agents) who produced it.
That makes this a governance problem as much as a code quality one. It’s the challenge I want to dig into here, how we make, defend and evidence decisions about software change when more of it is written by agents and fully read by fewer humans.
For this piece, I’ll draw on research from Resilient Cyber partner Cytix on how security leaders are handling software change, and pair it with my own experience in AppSec, vulnerability management and as a CISO, along with what these shifts mean for security.
In this article, I’ll walk through the landscape first, from the velocity agents are creating to what the data says about stale findings, untraceable incidents and evidence, before looking at how Cytix approaches the problem and how you can benchmark your own organization.
So, let’s take a look at how the SDLC has changed, and what it means for us in security.
Cytix built the free Software Change Confidence Benchmark, which lets you privately answer the same questions as 250 security leaders and see how your organization compares.
Velocity Meets Verification
To put the pace of change into perspective, the same Octoverse report found developers pushed code 17.9 billion times in the past 12 months, more than in 2024 and 2025 combined, while merged pull requests more than tripled to 1.3 billion, an average of 3.5 million a day.
Among repositories created this year, GitHub also found the average repo with an agent configuration file logged eight times as many commits as the average new repo without one.
Every one of those commits and merged pull requests is a software change, and in theory each one is a security decision somebody is accountable for.
Security leaders are the ones signing off on that change, and recent research from Cytix, “We interviewed 250 security leaders on software change, here’s what we found out,” offers a look at how they’re holding up. The survey was run by Opinion Matters for Cytix between late July and early August 2026, covering 250 UK IT security leaders, from CISOs to Heads of AppSec, at organizations with 1,000 or more employees and an in-house development team.
The sample is UK-based, but I see it as broadly indicative of where the industry sits right now. While the UK has its own regulatory requirements and nuances, the findings resonate with me based on conversations I routinely have with security leaders here in the U.S. as well.
Their data shows how unevenly organizations have prepared for this velocity. 78% of the security leaders surveyed say their organization has mandated AI-assisted development (combining “strongly” and “somewhat” agree), yet only 40% strongly agree their security team has received adequate tools, budget and resources to support agentic AI software change, and just 38% strongly agree their organization is prepared for the volume of AI-generated code now entering the environment.

From my perspective this isn’t surprising, as we see nearly every organization feel the need to rapidly adopt AI, especially in its breakout use case. Organizations are feeling the pressure from the top down (e.g. the board), and from the bottom up (e.g. developers). Security is in the middle and has to help navigate this rapid adoption lifecycle securely.
Cytix’s own read is that the volume decision was taken at board level and the assurance decision was not, which tracks with what I’ve argued all year about security being a laggard in every major technology wave, from Cloud to SaaS and now AI.
Now, there is a nuance here on the AI side. Veracode’s Fall 2026 GenAI Code Security update found the average security pass rate for AI-generated code jumped from 56% to 62%, the first meaningful movement in their series over the last couple of years, while still noting that roughly 4 in 10 AI code generation tasks in their test produced code with a known vulnerability. In other words, yes, models are getting better at producing secure code, but roughly 40% of AI coding tasks still produce code with a known vulnerability.
So models are getting somewhat safer per task, at the same time as the number of tasks is multiplying. This is important because as we saw from the GitHub data above, even if models are getting slightly better at writing more secure code, the overall velocity and volume of code has grown dramatically, which means so has the attack surface.
Interestingly, Cytix itself says it would “resist framing any of this as an AI security problem,” and treats AI-assisted development as pressure on software change, where the unit that matters is still the ticket, the pull request, the diff and the release. I think that’s a good perspective to take, and it’s why I wanted this to be more than another AI code security piece.
Much of my writing this year, including “There’s No Bucket Big Enough,” has focused on AI’s industrialization of vulnerability discovery and the reality that our defenses need to work with vulnerabilities still present. The other side of that coin is the industrialization of software change itself, along with the governance that has to keep pace with it.
So while it is promising that per-change code quality is improving, it is still far from perfect and the increase in volume very likely offsets the modest quality improvements in aggregate.
Findings That Arrive Too Late
The first finding in the research is one most AppSec practitioners will recognize immediately. 53% of security leaders (strongly and somewhat agree combined) say security findings in their organization are frequently out of date by the time they reach the people who need to act on them.
When asked what concerns them about their current software change management processes, 36% said security testing results aren’t connected to the specific change that introduced the risk, 31% said testing is disconnected from the business context of the change, 28% said testing can’t keep pace with software change, and another 28% said tickets lack the detail and context security teams need to act on.
Cytix makes a point here I really like, which is that a late finding is a different object from a timely one. By the time it lands, the engineer has moved on, the code has changed, and the work of reconstructing why the change was made falls to whoever happens to be holding the ticket. In other words, it has lost most of its value.
This is the same legacy vulnerability management pattern I’ve been critical of for years, where security throws low-context findings over the wall to development teams and drags velocity to a crawl, functioning as a business tax rather than an enabler.
I wrote about how the point of intervention keeps moving in “The ‘Left’ in Shift-Left Moved,” and this data is a good reminder that timing and context matter as much as the finding itself.
Throwing stale findings at developers leads to frustration on their end, a lack of trust in us in security, and reinforcing the very silos between development and security that DevSecOps set out to break down.
The path forward is truly shifting left by embedding security into AI-native IDEs and agentic coding tools, embedding historically paper-based policies into development workflows via skills and other mechanisms, enabling AI-native threat modeling and helping us close the gap from shifting left being a talking point to being a technical implementation reality.
Signing Off Anyway
Nearly half (48%) of the security leaders surveyed have signed off on a release they weren’t fully confident was secure. It’s a key finding in the report, and Cytix walks through the nuance behind it. These are experienced leaders running security functions at large organizations, and the report’s explanation is that the moment arrived, the release was ready, the business was waiting, and the information in front of them didn’t settle the question either way.
Nearly half (48%) of UK security leaders surveyed have signed off on a release they were not fully confident was secure.
Anyone who has sat in the security leadership seat knows release decisions rarely wait for perfect information and the business sure as hell isn’t going to sit on their hands waiting on security to feel perfectly comfortable.
From a governance perspective, a sign-off made on incomplete information is a risk acceptance that nobody formally recorded, and that is exactly the kind of decision auditors, regulators and boards eventually ask about.

The research also found that 62% of security leaders (strongly and somewhat agree combined) say security risk in their organization is moving from a latent problem to an immediate one. Cytix calls that the sentence the report is really about, and I’d agree it’s the one that reframes the others.
Software risk used to behave like a slow accumulation managed over quarters, with a reasonable expectation that today’s unreviewed change probably wouldn’t become this week’s incident. A strong majority of these leaders are saying that buffer is gone and the risk being introduced is imminent.
Any of us who have been in security know this feeling. We never have perfect information to make a decision, we often have to make do with the information at hand, and our best option is typically to empower the business to make a risk-informed decision, knowing they are going to move forward one way or another anyway.
After the Incident, Archaeology
The second finding gets at traceability. Only 36% of security leaders strongly agree they have visibility into which specific software changes introduced risk after a security incident.
Among organizations that experienced a security incident in the past three years, the reported causes were spread almost evenly. 29% pointed to a third-party dependency or open source component, 29% to a change made outside the standard development process (shadow IT, a hotfix or an emergency release), 27% each to a flaw in third-party software, a cloud or deployment misconfiguration, and a bug present for more than 30 days before discovery, 26% each to a weakness introduced by AI-generated code and chained vulnerabilities, and 25% to a change that was never reviewed.

Cytix draws two conclusions from this that I think are spot on. First, an even distribution tells you there is no single control to buy your way out of, and second, the top two causes are both situations where the organization’s normal review path was never in play.
If a change can enter production without passing through the process that would have qualified it, there is no record to trace back to after an incident, and the forensic work becomes what Cytix calls “archaeology,” digging through tickets, Slack threads, commit history and someone’s memory of a Friday afternoon to figure out what happened and how.
It’s also worth pointing out that AI-generated code sits mid-pack at 26%, right alongside chained vulnerabilities and long-lived bugs, which supports the idea that this is a software change problem that AI is accelerating, more than a purely AI problem.
On emergency changes, Cytix takes a pragmatic position I agree with. Hotfixes and emergency releases are a legitimate operational necessity, and most change processes force teams to choose between shipping the fix now and keeping the evidence trail intact, which is a choice the process shouldn’t be forcing in the first place.
There’s also another nuance here. With the rise in software supply chain security incidents, we’re increasingly seeing cases where the patch itself can be poisonous and introduce risk to the organization, but we also know delays in patching leave you exposed, so teams often have to move forward and hope for the best.
Another thing I want to call out is historically we have prioritized vulnerabilities based on severity, such as prioritizing Critical and High findings over Medium and Low. That made sense then, assuming you were truly rating them and not using base CVSS scores. But now, we’re seeing agents capable of stringing together low and medium findings via vulnerability chaining to take those historically less important findings and make them impactful.
Evidence as a Reconstruction Job
This is the section that resonated with me most from the report, because it gets at governance directly. Teams simply can’t keep pace with change velocity from a governance perspective, and the research shows what that looks like in practice.
When asked about the biggest barriers to producing evidence of which software changes over the past 12 months have been security tested, 41% said the volume of change is too high, 36% said testing happens too late in the release cycle, 36% said reporting doesn’t connect to individual changes, 35% cited the diligence of the humans inputting information, and 30% said there is no clear ownership of the review process.
Separately, 18% named the absence of a continuous evidence trail for auditors or customers as a concern with their change management process.

Read the top three together and they describe a single mechanism, where volume outruns the process, the process runs late, and the output isn’t attached to individual changes. The result, as Cytix puts it, is that evidence becomes a separate project undertaken after the fact, usually under deadline, rather than a by-product of the work.
The 35% figure deserves particular attention. A third of security leaders are telling us the reliability of their evidence depends on how carefully individuals filled in forms, which Cytix aptly describes as a control that exists “only in someone’s conscientiousness on a busy day.”
I’ve argued for years that compliance does equal security, just not the elimination of risk, and that the problem is how we do compliance, with point-in-time snapshots and manual evidence gathering that has more in common with performative arts than assurance. This is where practices such as GRC Engineering and moving to a continuous methodology of assurance can make a big difference.
This is why change governance matters so much for regulated businesses, where evidence of how a change was assessed is an obligation.
If you are like me and think GRC must evolve from being largely security theater with manual cumbersome snapshot-in-time activities, you’ll likely enjoy my prior article “GRC is Ripe for a Revolution”.
Proportion Over Friction
The research also captures the friction security is still known for. 32% of security leaders believe security is seen as a blocker to development velocity, 30% say it’s difficult to prioritize findings because there are too many vulnerabilities and no clarity on what to fix first, and 29% say the business perceives it as too costly to test every software change.
Cytix’s take is that these numbers describe an information problem, even though they usually get treated as a culture problem to be fixed with better relationships. Security comes across as indiscriminate friction when it applies the same scrutiny to a copy change and a change to an authentication flow, and if every change is treated as equally deserving of testing, the business is right that testing all of them costs too much.
“Proportion is what turns a blocker into a filter.”
This is a big part of how we shed our longstanding reputation as the “office of no.” Making secure by design something teams can actually operate means scrutiny matched to the risk of each change, with low-risk changes moving quickly and high-risk ones getting real attention, while developers keep shipping.
I like this framing of applying proportional security, because it helps us honestly admit we don’t have the bandwidth to be everywhere all the time, at least not at the same level of rigor, and instead rightly points out that some changes warrant more scrutiny from security than others.
How Cytix Approaches It
With the landscape laid out, let’s look at what Cytix is building. Cytix describes itself as “the risk management platform for software change, acting as the security decision layer for a world where software development never stops,” sitting between a software change and the security response chosen for it.
The platform runs the same four questions against every change it sees, namely whether it matters, what could go wrong, what a proportionate security response looks like, and how all of that gets reported back to the change.
The report walks through an example that makes this concrete. A developer opens a ticket and pull request changing how session tokens are validated in a customer-facing application, some of the code was AI-assisted, and the ticket description is two lines long, which anyone who has worked with development teams will recognize as normal.
Cytix assembles context around the change, including the affected asset, the environment it runs in, prior findings on that component, repository signal, documentation and workflow metadata, so the two-line ticket becomes a pointer to the input rather than the input itself.
It then qualifies whether the change matters and what response it justifies against the organization’s own policy and thresholds. In this case, authentication logic in a customer-facing path warrants attention, while for the majority of changes the honest answer is that they don’t, and Cytix treats saying so as just as valuable as escalating.
The response is routed into the systems teams already use, whether that’s more context, a human review, an updated threat model, a design change, a specific validation or penetration test, a remediation item, or an accepted risk recorded as such. Cytix works with Jira, Azure DevOps and GitHub Issues, and is triggered by existing tickets.
Finally, the decision, rationale, action and outcome stay attached to the change that caused them, which is the thread the 36% in the traceability finding don’t have today, and what turns evidence into a by-product of the work.
On its homepage, Cytix breaks this into four steps, using a persistent knowledge graph of the live system landscape to understand change, making data-led decisions that prioritize high-risk changes and auto-approve low-risk ones, validating risk through a multi-agent orchestration framework with change-driven testing, and logging every decision, test and finding to the change that triggered it.
Cytix raised a $7M Series A in August, led by Northern Gritstone.
Ben Armstrong, Cytix’s CEO, summed up the gap in that announcement, saying:
“Existing tools can tell you what vulnerabilities you have, but can’t tell you about the risk.”
In terms of where this fits, I’d think about the market in three broad categories, with some tools focused on preventing insecure code from being written, others on detecting vulnerabilities once it exists, and Cytix sitting closer to the govern side, connecting each change to a risk decision the business can defend.
I like this approach because it starts with the change itself, which is the unit security, development and GRC all already share. That said, auto-approving low-risk changes is only as good as the details and context behind it, and the first question many CISOs will ask is how explainable and auditable those decisions are, which Cytix addresses directly with its claim that every recommendation is explainable and every decision is recorded.
I think helping security prioritize changes and looking to automate changes that don’t introduce significant risk can free us up and act as a force multiplier at a time when most security teams are feeling overwhelmed and factors such as AI’s industrialization of vulnerability discovery and the broader business adoption of AI are making teams feel even further behind.
Where Do You Stand?
One of the more useful pieces of this research is that you can measure your own organization against it. Cytix built the Software Change Confidence Benchmark, a free tool that lets you privately answer the same questionnaire as the 250 security leaders in the research and compare your position to theirs.

A few of the benchmark’s questions make practical places to start. How long does it take to tell a developer whether their change is risky, and if a regulator or major customer asked how you decide which changes get scrutiny, how comfortable would you be with your answer?
After your last incident, was identifying the change that introduced the risk a query or an investigation? And how many of the changes you review end up not needing security attention at all?
These are good questions many organizations don’t take the time to ask or answer, yet they could help them optimize their change management processes and focus finite time and attention where it could make the most impact and automate areas where the opportunities exist, to alleviate workloads on teams.
Closing Thoughts
This is far from an exhaustive discussion on software change, but the research makes a compelling case that the gap security leaders are wrestling with sits in the decision before testing and the evidence after it.
AI-assisted development has made that gap impossible to ignore, and governance that can keep pace with software change is how secure by design moves from a concept to something teams can actually operate.
How many of the releases your organization shipped this quarter were signed off on confidence?
Given the rate of AI-driven development and its impact on software volume and velocity as well as fundamental changes to the SDLC, the answer is likely not as many as we’d like.









"Interestingly, Cytix itself says it would “resist framing any of this as an AI security problem,”
Of course, they do. Everyone wants the AI Bubble to succeed and therefore decides to look away from the problems.
Meanwhile, more and more people are writing articles describing how the software industry is falling apart, and more and more analysts who actually audit AI-generated code are finding unmaintainable crap, while we have major outages on an almost daily basis now from all the major players.
Idiots.