AI-native software engineering raises new control gaps for security

At a glance

What this is: Veracode argues that AI-native software engineering is widening control gaps as AI moves from assistance to agentic execution across the SDLC.

Why it matters: Security, IAM, and engineering leaders need to govern AI-assisted workflows, not just code quality, because trust, approval, and supply-chain controls now sit in the critical path.

By the numbers:

• 90% of enterprise software engineers are projected to use AI code assistants by 2028, up from less than 14% in early 2024.

Context

AI-native software engineering changes the control problem inside the SDLC. The issue is no longer only whether code is generated faster, but whether organisations can govern AI-assisted actions, approvals, and remediation with enough traceability to trust the outcome.

That creates a real governance overlap between application security, software supply chain control, and identity management. When AI systems translate intent into actions, the security model has to account for who or what can act, approve, or propagate context across a workflow.

For most teams, the starting point is still immature: security controls were designed for human developers and review gates, not for semi-autonomous software engineering workflows that can create, modify, and pass along code context at machine speed.

Key questions

Q: What breaks when AI-generated code is reviewed without security gates?

A: What breaks is the assumption that a clean-looking diff is a safe diff. AI-generated code can hide unsafe defaults, dependency issues, and weak validation that basic review misses. Without CI-enforced tests and security checks, the merge process becomes a distribution channel for defects rather than a control point.

Q: Why does AI make software supply chain risk harder to control?

A: AI increases the amount of code produced, which reduces the time available for review and makes malicious or unauthorized changes harder to spot. It also introduces non-human actors into the development flow, so traditional assumptions about developer identity no longer hold. That combination expands the attack surface at the commit stage.

Q: How do security teams know whether AI-assisted remediation is actually under control?

A: Look for three signals: human approval still exists before code creation, pull requests identify machine-authored changes clearly, and deployment permissions are not inherited from build status alone. If any of those are missing, the workflow is behaving more like delegated execution than assisted analysis, and the governance model is too weak for the level of automation involved.

Q: Should organisations treat agentic workflows differently from standard developer tooling?

A: Yes, because agentic workflows can act across multiple steps and tools rather than only suggesting a change. That means authority, context transfer, and approval become part of the security design. Organisations should govern the workflow itself, not just the final code it produces.

Technical breakdown

How agentic workflows change SDLC trust boundaries

Agentic workflows are software-driven task chains in which an AI system can interpret intent, decide on a next action, and move work forward with limited human prompting. In software engineering, that means a model may generate code, refactor it, call tools, and hand context to the next step in the pipeline. The control gap is not just output quality. It is the loss of a stable trust boundary when action and review are decoupled across multiple systems and participants.

Practical implication: treat AI workflow steps as governed execution points, not just productivity features.

Why AI-generated code creates supply chain and quality risk

AI-generated code can reduce routine effort, but it can also introduce duplicate logic, insecure defaults, hidden dependencies, and configuration mistakes that look correct to a reviewer at a glance. In a supply chain context, the risk extends beyond source code to what the code depends on, how it is built, and whether changes are traceable back to an accountable decision. If the review process only checks the final artefact, defects can move downstream into production before anyone sees them.

Practical implication: extend application security and SCA checks to the full AI-assisted change path.

Why human-in-the-loop controls matter for AI remediation

Human-in-the-loop is not a slogan here, it is a control design choice. When AI suggests fixes for vulnerabilities, the risk is that remediation becomes accepted by default, even where the suggestion changes behaviour, weakens policy, or creates new exposure. The more autonomous the workflow, the more important it becomes to preserve accountable approval for critical changes. That is especially true when code changes can affect authentication, access control, or deployment configuration.

Practical implication: require explicit human approval for security-sensitive code changes and automated fixes.

NHI Mgmt Group analysis

AI-native development is now an identity and governance problem, not just an application security problem. When tools can generate, modify, and propagate code context inside a workflow, the organisation is no longer managing only developer productivity. It is managing delegated action inside a software supply chain that needs clear authority, review, and accountability. Practitioners should treat AI-assisted development as a governed identity-and-control surface.

Context drift is the new failure mode in multi-agent software workflows. The article’s strongest warning is not merely about bad code, but about AI-generated context being passed between agents and trusted without sufficient verification. That creates a governance gap where each step appears locally reasonable, yet the full chain is never revalidated. Security teams should look for places where context is inherited faster than it is checked.

Software supply chain assurance must expand from artefact integrity to action integrity. Traditional controls focus heavily on what gets built and shipped, but AI-native engineering requires scrutiny of who or what initiated the change, which model influenced it, and which approvals were bypassed. This is a material shift for software governance because it turns workflow provenance into a first-class control objective. Practitioners need evidence that every AI-assisted change can be explained and challenged.

AI code assistants create governance debt when organisations optimise speed before control. The projected adoption curve means many teams will inherit these patterns before their operating model is ready. That does not mean slowing adoption to a halt, but it does mean security leaders should re-baseline review thresholds, exception handling, and remediation authority now. The practical lesson is to govern AI assistance as a persistent workflow risk, not a future-state concern.

What this signals

Action integrity will matter as much as code integrity. AI-native engineering pushes the security question upstream into how decisions are made, approved, and handed from one tool or agent to another. For practitioners, that means review policies and audit evidence need to cover the workflow, not only the final artefact.

Security teams should expect a widening gap between delivery speed and governance maturity unless they add explicit control points for AI-assisted changes. The organisations that adapt fastest will be the ones that can prove who approved what, and why, when the code was not written only by humans.

For practitioners

• Define review gates for AI-assisted changes Classify security-sensitive changes, such as authentication, authorisation, infrastructure configuration, and dependency updates, so they always require explicit human review before merge or deployment.
• Extend supply chain checks to AI-generated code Run SAST, SCA, and configuration validation on AI-produced output exactly as you would on human-written code, with special attention to hidden dependencies and duplicate logic.
• Track provenance for agentic workflow outputs Record which prompt, model, tool call, and approval path produced a change so teams can trace how context moved through the workflow if a defect appears later.
• Set policy for autonomous remediation suggestions Require developers or security owners to approve any AI-generated fix that changes security behaviour, rather than allowing automated acceptance based on confidence alone.

Key takeaways

• AI-native software engineering changes the control problem by introducing machine-driven actions into parts of the SDLC that were built around human review and approval.
• The clearest risk is governance drift, where faster code production obscures defects, weak dependencies, and unclear accountability across the software supply chain.
• Security leaders need to govern AI-assisted workflows as a distinct change path, with traceability, approval, and validation controls that match the speed of automation.

Key terms

• Agentic workflow: An agentic workflow is a sequence of tasks executed by an AI agent with some level of tool access and decision authority. In security terms, the workflow matters because it can span multiple systems, identities, and permissions, which makes attribution and revocation harder than with ordinary automation.
• Action integrity: Action integrity is the assurance that a request, approval, signature, or writeback can be traced to the same verified identity and preserved as one defensible record. In regulated environments, it matters as much as authentication because it ties user activity to evidential value.
• Human-in-the-Loop (HITL): A governance pattern requiring human approval before an AI agent takes high-impact, irreversible, or out-of-scope actions. HITL is a critical control for agentic AI identity governance.
• Software Supply Chain Risk: Software supply chain risk is the chance that code, build, deployment, or dependency paths are altered in ways that affect downstream systems. For AI code assistants, this risk rises when the tool can change source, trigger pipelines, or influence infrastructure definitions.

Deepen your knowledge

The NHI Foundation Level course, the industry's only accredited NHI security programme, covers NHI governance, agentic AI identity, machine identity security, IAM, and secrets management. It gives practitioners a practical foundation for governing non-human actors in modern security programmes.