Claude Code Security exposes the identity gap behind faster development

At a glance

What this is: This is an analysis of Claude Code Security that argues faster code scanning does not close the identity gap created when agentic development expands Shadow SaaS and residual access.

Why it matters: It matters because IAM, IGA, and PAM teams have to govern the browser-based tools, shared logins, and offboarding paths created around AI-assisted development, not just the codebase it produces.

Context

Claude Code Security is a contextual code-scanning capability embedded in agentic development workflows. The article argues that the security problem does not end at code quality because faster software creation pushes developers toward unmanaged tools, browser logins, and shadow applications outside the corporate identity perimeter.

For IAM and NHI programmes, the issue is not whether development becomes faster, but whether identity governance can still see the accounts, credentials, and offboarding dependencies created as teams assemble toolchains on demand. That is the structural blind spot the article highlights.

The article’s central claim is that shift-left security can improve code review, while identity drift around the development stack expands faster than enterprise controls are usually extended. That makes the surrounding access layer the real governance problem.

Key questions

Q: How should security teams govern Shadow AI in SaaS applications?

A: Security teams should govern Shadow AI by classifying AI-capable SaaS tools, deciding what data each tool may process, and enforcing those decisions centrally. Discovery is necessary but not sufficient. The control layer must cover model training, retention, sharing, and exceptions so users cannot create hidden data-use risk through ordinary application activity.

Q: Why do unmanaged developer tools increase access risk even when code scanning improves?

A: Because code scanning protects the application, while unmanaged tools protect the surrounding workflow. Shared passwords, browser-cached logins, and orphaned SaaS accounts create alternate entry points that code quality checks cannot see. The risk rises when access lives outside the directory and survives beyond the project that created it.

Q: What breaks when offboarding does not include non-SAML accounts?

A: The primary directory account is removed, but the supporting accounts used to build, test, and deploy code remain active. That leaves residual access in services the enterprise cannot readily enumerate or revoke. The practical failure is not incomplete deactivation, it is fragmented identity ownership across the development stack.

Q: How can IAM teams reduce residual access in AI-assisted development environments?

A: Start by tracing which accounts were created to support a specific engineering workflow, then tie those accounts to a lifecycle owner and a revocation path. The goal is to make offboarding capture the surrounding SaaS, not just the employee directory record. Without that, leaver cleanup will always be partial.

Technical breakdown

Agentic coding accelerates Shadow SaaS creation

Agentic coding tools can compress the time between idea, prototype, and deployed service, but they do not change how niche tools are provisioned or governed. Developers still reach for browser-based signups, personal credentials, and untracked services when the approved path is slower than the build path. That creates Shadow SaaS, meaning applications and accounts that support work but sit outside formal identity governance. The code may be reviewed earlier, but the operating environment around it becomes less visible, not more. Practical implication: treat development velocity as an identity governance input, not just a productivity metric.

Practical implication: inventory the browser-based tools and ad hoc accounts that emerge around fast-moving AI-assisted development.

Why SSO coverage breaks in the developer toolchain

Traditional IdPs work best when applications support federation through SAML or OIDC and when access can be tied to a managed lifecycle. Many specialised developer tools, staging environments, and AI infrastructure platforms do not fit that model cleanly, or they push SSO behind friction that teams work around. The result is shared passwords, reused credentials, and browser-saved logins that sit outside enterprise policy enforcement. This is an identity perimeter problem, not a code security problem. Practical implication: map which parts of the dev stack are federated, which are not, and which become credential islands.

Practical implication: identify the non-federated applications that force developers into password-based access patterns.

Residual accounts create post-offboarding exposure

Offboarding often closes the primary directory account while leaving behind the auxiliary access created during project work. In an AI-assisted pipeline, that can include shared SaaS logins, testing environments, and browser-cached accounts that were never attached to the corporate directory in the first place. Those residual accounts remain active because the enterprise has no authoritative inventory of them and no lifecycle hook to revoke them together. This is where the access model fails: revoking one identity does not revoke the surrounding shadow ecosystem. Practical implication: offboarding has to include discovery of non-directory accounts tied to the leaver’s workflow.

Practical implication: extend offboarding checks to the shadow accounts created during development workflows.

Threat narrative

Attacker objective: The objective is to exploit the unmanaged identity surface around faster development so access persists beyond normal directory controls and offboarding.

1. Entry occurs when developers adopt unmanaged tools and browser-based signups to keep pace with agentic development.
2. Credential exposure follows when shared, reused, or browser-cached passwords are created for non-SAML services around the code workflow.
3. Escalation happens when those residual accounts survive normal offboarding and remain attached to systems that host, test, or deploy code.
4. Impact is persistent, unmonitored access into the development and deployment environment through accounts that the enterprise cannot govern end to end.

Breaches seen in the wild

• Nx s1ngularity attack 2025: Attackers stole Nx's npm token via a GitHub Actions flaw and shipped malware that stole 2,349 secrets and abused developers' AI CLIs.
• Scania insurance portal breach 2025: An attacker used an external user login, likely stolen by infostealer malware, to take insurance claim documents from a Scania portal.

Read and download The State of NHI & AI Agent Breach Report 2026, covering 200+ breaches impacting Non-Human Identities including AI Agents.

NHI Mgmt Group analysis

Claude Code Security changes code review cadence, not identity governance boundaries. The article’s core problem is that faster development creates more unmanaged access paths around the codebase than traditional IAM can see. Security teams should not confuse earlier scanning with earlier control. The practitioner conclusion is that the surrounding identity perimeter matters as much as the application logic.

Shadow SaaS is the real scaling risk in agentic development. When developers can spin up niche tools, staging systems, and AI helpers in minutes, enterprise approval models lose their pacing advantage. That creates a governance gap where the build system is more visible than the systems used to operate it. The implication is that discovery and lifecycle control must extend beyond managed enterprise apps.

Identity governance fails when the application stack is assembled faster than offboarding can be correlated. The article shows a residual-account pattern: directory deactivation succeeds while browser-saved, shared, and non-SAML accounts remain live. That is not just incomplete coverage, it is lifecycle fragmentation across the development toolchain. Practitioners should treat the developer environment as part of the identity control plane.

Identity perimeter expansion, not code analysis, is the decisive control problem. Claude Code Security can improve upstream code quality, but it cannot govern the browser-based ecosystems that agentic coding encourages. The field needs a broader view of access authority, one that spans federation, account lifecycle, and shadow application discovery. The practitioner conclusion is to align identity governance to the full software-production path.

Shadow SaaS identity debt: This article exposes a build-speed problem that becomes an identity-security debt problem as soon as unmanaged tools accumulate faster than governance processes can inventory them. That debt compounds at offboarding because invisible accounts outlive the employee relationship. The implication is that programmes must measure the unmanaged access layer, not just the managed one.

From our research library:

• Claude Code-assisted commits leaked secrets at a rate of 3.2%, more than double the human-only baseline of 1.5%, with peaks reaching 31 secrets per 1,000 commits in August 2025, according to the State of Secrets Sprawl 2026.
• Companies are dedicating an average of 32.4% of their security budgets to secrets management and code security, with US organisations leading at 40.8%, according to the State of Secrets in AppSec.
• Read next: Ultimate Guide to NHIs — Key Challenges and Risks

What this signals

Shadow SaaS identity debt: When developers can stand up tools faster than IT can approve them, governance debt accumulates in the form of unmanaged accounts, browser-cached credentials, and orphaned access paths. That debt is visible first at offboarding, when the directory is clean but the supporting ecosystem is still live.

Identity teams should expect the development toolchain to become part of the access surface, not a separate technology problem. The practical shift is from reviewing only managed applications to discovering which browser-based services hold credentials, approvals, and residual entitlements outside the directory.

For practitioners

• Map the shadow software estate Inventory the browser-based tools, niche SaaS apps, and ad hoc developer platforms created to support AI-assisted coding workflows. Prioritise systems that never entered procurement or the directory.
• Classify federation gaps in the dev stack Separate applications that support SAML or OIDC from those that force password-based access or browser-cached logins. Treat the unfederated group as a high-risk identity perimeter gap.
• Extend offboarding beyond the primary directory When an engineer leaves, revoke the directory account and then trace the residual logins, shared credentials, and testing environments created during the build workflow.
• Eliminate shared developer credentials Replace browser-saved passwords and shared logins with centrally governed access patterns for staging, deployment, and collaboration tools used by engineering teams.
• Require discovery before approval Do not approve new developer tooling until the team can show where identity is managed, how access is revoked, and which accounts persist outside the corporate perimeter.

Key takeaways

• Faster code scanning does not remove the identity risk created when agentic development expands the number of tools, logins, and accounts around the codebase.
• The article’s evidence points to a governance gap in Shadow SaaS, shared credentials, and orphaned accounts rather than a pure application-security weakness.
• Practitioners need to extend identity inventory and offboarding into the development toolchain, or residual access will survive after the primary directory account is removed.

Key terms

• Shadow SaaS: Shadow SaaS is the set of unauthorised or unreviewed software-as-a-service tools used outside central security governance. These applications often bypass normal identity controls, making them difficult to inventory, monitor, and harden against credential-based abuse.
• Residual Account: A residual account is an external or secondary identity that remains active after the original user, project, or workflow should no longer need it. These accounts are especially risky in modern development environments because they can preserve access long after directory offboarding appears complete.
• Identity Perimeter: The identity perimeter is the access boundary defined by who or what is requesting entry, not by where the request comes from. In zero trust, it is the point where authentication, authorization, and risk context decide whether a caller can proceed.
• Lifecycle Fragmentation: A condition where each agent or team follows a separate delivery path, with its own testing, review, and monitoring assumptions. The result is inconsistent control outcomes, weak organisational memory, and repeated reinvention of the same governance tasks across the portfolio.

Deepen your knowledge

NHI governance, agentic AI identity, and machine identity security are core topics in our NHI Foundation Level course, the industry's only accredited NHI security programme. If you are building or maturing an IAM programme, it is worth exploring.