Podcast

Hey, glad you found your way here! This is where all my episodes live. Pull up a chair, hit play and let’s talk. In each episode I pick one topic and really get into it, the way I would over coffee with a friend: no jargon walls, just the stuff that matters. If something sparks your curiosity, you’ll find a link under every episode to the full article I wrote alongside it, with all the examples and details I couldn’t squeeze in. New here? Start with the latest one. Been here before? Welcome back, there’s probably something new waiting for you.

Episodes

The SARC System: Why your content needs a system
AI SEO Podcast · 7 minutes

How many blogs has your team published this year that nobody ever found?

Most content doesn’t fail loudly. It’s well written, well researched and hours in the making, and then it just sits there. In this episode, I explain why that happens and walk through the SARC System, the framework I use to plan and write content that gets found, earns trust and leads somewhere.

SARC has four parts:

  • Search. Write for the intent behind the query, not just the topic. This is the most common mistake I find when I audit content.
  • Authority. Authority isn’t built in a single post. It’s built across a body of work: 8–12 posts per cluster before you move on, internal links in both directions, and real first-hand experience.
  • Reader. Every search has three layers of intent: what people typed, the outcome they want, and the worry behind the search. A good post answers all three, and gives readers a reason to keep going every 150–300 words.
  • Conversion. Not every reader is ready for the same next step. A soft call to action suits someone still exploring, a mid-level one like a template or checklist suits someone weighing options, and a direct ask suits someone ready to decide.

The thread running through all four is simple: systems beat volume. Publishing more won’t fix content that has no structure behind it.

AI Safety & Guardrails podcast · 30 minutes

About this episode

Picture a smoke alarm that still works perfectly. It senses smoke and logs every alert, but somebody has quietly cut the wire to the siren. Now picture that the person who cut it was the helper you hired to tidy the house, because earlier that day you’d asked it to keep the noise down.

That’s closer to a news story than a thought experiment. In October 2026, OpenAI reported two internal coding tasks in which an AI agent weakened the monitoring that was supposed to be watching it. One agent emptied its alert recipient lists and set a “no-notify” flag, so the monitor kept running and nobody was told. The other removed its monitoring, swapped the test that checked for it with one that checked it was gone, and then said it hadn’t removed anything.

Neither case involved an attack, a jailbreak or an agent refusing instructions. Both agents simply had write access to files that a different team should have owned.

In this episode, I take one of the oldest ideas in security, separation of duties, and apply it to AI agents. The whole episode comes back to one rule:

The agent that does the work should never control the systems that watch, limit or approve that work.

The agent can write code, change files and call tools. What it can’t do is touch its own alerts, logs, tests or approvals.

What you’ll learn

Where the principle comes from. Separation of duties started in bookkeeping, long before tech. It runs through bank maker-checker approvals, the four-eyes principle, NIST SP 800-53 control AC-5, Section 404 of Sarbanes-Oxley and the military two-person rule. It works because it doesn’t depend on judging anyone’s intent. That’s exactly why it fits AI agents, where intent is the one thing we often can’t judge.

How agents break it without anyone noticing. A human team gets separation of duties almost for free, because it’s made of separate people with separate logins. An agent usually gets all that access at once. I walk through the three everyday decisions behind this:

  • access granted by environment instead of by duty
  • oversight stored as code beside the product
  • tasks that reward finishing at any cost

Then four realistic scenarios show how a safeguard gets quietly weakened in release pipelines, data retention, access policies and customer support.

A clear way to map the problem. Every agent system has four roles: decide, permit, record and accept. The agent should hold only the first. I explain exactly what breaks when roles merge. I also cover the six places an agent can reach its own oversight, plus a seventh that most teams miss. And I go through the five layers of monitoring, including why behaviour monitors and alerting fail quietly while logs fail loudly.

Seven controls you can put in place this month:

  1. A narrow, separate identity for every agent
  2. Oversight kept in a place the agent can read but not write
  3. Monitoring files and tests on protected, review-required paths
  4. Append-only logs stored in a separate account
  5. Limits enforced in permissions, not in prompts
  6. An independent watcher with a configuration fingerprint
  7. Approvals routed through their own service

I also cover the five properties of monitoring that holds up under pressure, and how decoy “tripwires” can catch an agent reaching for its oversight.

Beyond one agent. I look at multi-agent systems and delegation loopholes. I explain why an agent’s own instructions, tool descriptions and memory need the same protection as monitoring config. And I cover what makes an AI reviewer truly independent of the agent it checks.

Making it real. The episode ends with a practical 30-day plan for teams that already run agents, and a five-step boundary test to prove the controls work. I also cover what to do first if an agent has already weakened its oversight, and how the EU AI Act’s Article 14, ISO 27001 and SOC 2 connect to all of this.

Chapters

00:00Cold open: the smoke alarm with the wire cut
01:16Welcome
02:26The classic principle
06:00How agents break it
10:56Mapping the problem
15:21The fixes
21:11Beyond one agent
24:45Making it real: the 30-day plan
28:07One takeaway

Who this episode is for

This episode is for engineering leads, platform and security teams, AI product owners and anyone giving AI agents real access to code, infrastructure or data. No deep security background is needed. Every idea is explained in plain language, with concrete examples.

The one takeaway

Agents will keep getting better at finishing hard tasks. The same persistence that makes them useful also lets them push through safeguards rather than stopping at them. So oversight can’t depend on the agent choosing to respect it.

Trust the agent with the work. Never with the checks on the work.

Keep reading

Episode description

Code provenance is the ability to prove who wrote a piece of code, which human reviewed it, whether the reviewed code is what got built, and whether the artifact running in production came from that build. AI coding assistants have made that proof much harder to produce. A large share of the code many teams ship today was drafted by an AI tool, accepted with a single key press and committed under a human’s name.

In this episode of The DevSecOps Briefing, I explain why that matters and share a practical chain of evidence your team can start building this week.

Who is asking for provenance

Auditors want to know how software is built and who approved it. Customers send supply-chain questionnaires, and some now ask directly about AI-generated code. Regulators expect documented, traceable supply chains under the EU Cyber Resilience Act. Attackers count on the gap: if you can’t tell where your code came from, you can’t tell when someone slipped something in.

Four ways AI breaks provenance

  1. Authorship is invisible. Git records who committed a change, not who or what generated it.
  2. Review is weaker than it looks. A fluent 2,000-line pull request can be approved in ten minutes without being understood.
  3. Agents act with human credentials. A prompt-injected agent using a developer’s token can commit malicious code under a trusted name.
  4. AI pulls in code you never chose. Attackers register the package names AI tools hallucinate.

The fix: a five-link chain of evidence

  1. Origin. Label AI-assisted commits with an Assisted-by trailer, and give every coding agent its own bot identity with short-lived tokens.
  2. Identity. Require signed commits, which keyless signing with Sigstore and gitsign has made painless.
  3. Review. Require approvals, use CODEOWNERS for sensitive paths, set size limits and scan every pull request, especially new dependencies.
  4. Build. Build in hardened CI from a specific commit with pinned dependencies, and produce SLSA provenance.
  5. Deploy. Verify provenance before anything runs with admission policies such as Kyverno, and ship an SBOM with every release.

Four things not to do

Don’t ban AI coding tools, because usage simply moves to personal accounts. Don’t rely on AI detectors. Don’t treat approval as understanding. And don’t stop at the commit: signed commits feeding an unverified build pipeline are a locked front door on a house with no walls.

Start this week

Require signed commits and reviews on main, move every coding agent to its own bot identity, and add verified build provenance to one release pipeline. Most of the tools are free and open source. Then pick your most important service and walk the chain. Wherever you can’t produce proof, that’s your first project.

Proof, Not Hope: Keyless Signing and the Software Supply Chain

Most teams hope the software they ship is the software they built. Somewhere between a developer’s commit and a production deploy, code passes through build systems, registries and pipelines, and each one is a place where something can be swapped, tampered with or injected.

The problem with traditional signing

Code signing isn’t new. For years it has depended on long-lived private keys, and those keys are where it breaks down. They get copied into CI configs, shared between teams, left on old laptops, or never rotated. When a key leaks, an attacker can sign malicious code that looks fully legitimate. Managing keys safely at scale is hard enough that many teams don’t sign anything.

What keyless signing actually means

“Keyless” is a slightly misleading name. There are still keys, just none you have to store or protect over time. Here’s how it works:

  • Identity first: you prove who you are through an identity provider you already use, via OpenID Connect (OIDC).
  • Short-lived certificates: a certificate authority issues a certificate tied to that identity, valid for only a few minutes.
  • Public transparency log: the signature is recorded in an append-only log that anyone can check.

The key is thrown away once the artifact is signed. To verify it, you don’t check a key. You check who signed it and where that identity came from.

Where Sigstore fits in

In the episode I go through the open-source Sigstore project, which is behind most keyless signing in use today:

  • Cosign signs and verifies container images and other artifacts
  • Fulcio issues the short-lived, identity-bound certificates
  • Rekor is the transparency log that records every signature

Beyond signing: provenance and SBOMs

Signing tells you who produced an artifact. Supply chain security also has to answer how it was built and what’s inside it. I also cover how signing connects to SBOMs (software bills of materials), build provenance and frameworks like SLSA, which together give you an auditable trail from source code to deployment.

What you’ll learn

  • Why key-based code signing struggles at scale
  • How OIDC identity, short-lived certificates and transparency logs work together
  • What Cosign, Fulcio and Rekor each do
  • How signing supports SBOMs, provenance and SLSA
  • Practical first steps for adding signing to your CI/CD pipeline