Is our sandstone approach to building a security culture actually accelerating modern day supply chain threats? Or mitigating them?

Today's software is built, not written. A typical application today is mostly third-party dependencies, stitched together by automated pipelines and now, increasingly involving autonomous AI agents. Attackers have also, as a result evolved accordingly: they no longer "hack" your app—all they need to do is to seek out a single lone obscure npm package, or compromise the maintainer’s account, or corrupt an LLM’s training data. The recent Axois npm compromise, the Trivy impacts on LiteLLM use, xz utils backdoor, the Polyfill.io domain seizure, and the whole emerging "dependency confusion 2.0" concept exacerbated with a proliferation of vibe coding mentality shows that supply chain attacks are now systemic, automated, and devastatingly fast. 

For years, the security culture we have strived to build relies on prehistoric assumptions: "trust the registry," "security pre-release reviews will catch everything," and "move fast, we can verify this later." This mindset actively accelerates our risk we intake. Developers auto-update dependencies without inspection. CI/CD agents run with overly broad permissions. And the rise of vibe coding—generating code via AI without mastering the basics—means that teams no longer understand what they even ship. The old culture which treats SBOMs as compliance paperwork and leveraging trust as a default. In a new era of agentic, non-human identities, that trust unfortunately becomes a weapon for attackers to abuse. 

A modern day approach now requires a radical shift in thinking. First, we need to assume compromise – and treat every dependency as potentially malicious until proven otherwise during runtime. Second, we need to shift from ownership to inheritance – you are liable for code you did not write and did not review. Third, we need to replace "move fast and break things" with "move fast, verify and attest conditionally" – every deployment must include a signed provenance (robust SLSAs) of who or what created each line, including the AI model and its settings and configurations. 

Practically, this means: having "always alive' SBOMs attached to every build, runtime-focused behavior policies (not just static scans being run), and strict governance of non-human identities (CI/CD tokens, code LLM agents etc.). Ensuring productivity inducing vibe-written code is allowed only to be allowed in sandboxes; production code requires a human who can explain every dependency that makes up the application. Framework like Sigstore and SLSA are no longer optional—they are the new minimum baseline to mitigate the supply chain risks we see in the modern-day landscape. 

The bottom line is: you no longer own your code. You inherit it from strangers and from what is generated by our non-human counterparts. The only path forward is with a change in how we build our security culture, we have to stop trusting and start verifying—continuously, at runtime, and with receipts.