$ today_in_10_seconds
Anthropic just shipped a Claude Security plugin that turns Claude Code into a team of agents that map your architecture, hunt vulnerabilities, and write verified patches — without leaving your terminal. It arrives at a pointed moment: coding agents have become the fastest-growing attack surface in software, so the same autonomy creating the risk is now being pointed at defending against it. The tell is in the design — every finding is adversarially verified before you ever see it.
$ lead_story
Claude Code becomes your in-terminal security team
Anthropic released the Claude Security plugin for Claude Code in beta — a multi-agent vulnerability scanner that runs entirely inside an existing Claude Code session. One command, /claude-security, spins up a team of agents that map the codebase architecture, build a threat model, hunt for vulnerabilities, and then independently review every finding before writing a report; you can scan a whole repo or just a branch/PR/commit diff before you commit. The part worth studying is the verification discipline: a patch file is only written if a verifier can confidently assert three things — it fixes the specific finding, introduces no new vulnerability, and changes no behavior — and any 'fix' that quietly weakens security (a loosened auth check, a disabled test) is an automatic reject. Nothing is auto-applied; patches land as files you review and merge in individual PRs. For developers, this is shift-left security collapsing into the coding loop itself — the same agent that writes the code now audits it, with an adversarial check against its own optimism.
// why_it_matters: The coding agent and the code auditor are becoming the same tool — and the credible version ships with an adversarial verifier that argues against its own findings.
$ also_worth_attention
Why this is urgent: coding agents are 2026's fastest-growing attack surface
The defensive push exists because the offensive side exploded. Recent disclosures include 'GuardFall,' a shell-injection design flaw that bypassed safety guards in 10 of 11 open-source coding agents (collectively ~548k GitHub stars) by exploiting the gap between the string a guard inspects and what bash actually runs, and 'agentjacking,' where a public Sentry error-reporting key lets an attacker plant instructions that MCP-connected agents (Claude Code, Cursor, Codex) execute with the developer's own privileges — 85% success across 2,388 exposed orgs in testing. The insight: string-based denylists and static skill scanners are failing against compositional attacks, because untrusted text keeps reaching a real shell before any guard understands it.
link →The emerging doctrine: 'Agent Zero Trust'
The structural response taking shape across the industry — including frameworks from Google DeepMind and Anthropic — is to treat autonomous agents as potential insider threats rather than trusted tools. That means cryptographically verifiable guardrails, strictly scoped agent identities, and runtime monitoring of the whole execution chain, instead of hoping a model-level filter catches bad behavior. Today's Claude Security plugin fits the doctrine neatly: it assumes its own findings might be wrong and verifies them adversarially. The insight: as agents get autonomy over real systems, 'trust but verify' collapses into just 'verify' — at the identity, action, and output layers all at once.
link →The capability that makes it necessary: repo-scale coding agents
The reason security has to move into the loop is that coding agents now act at repo scale. A wave of mid-July upgrades pushed agents from OpenAI, Anthropic, and Google toward end-to-end software modifications spanning hundreds of files, grounded in your actual repositories and dev tools, iterating against tests as they go. When an agent can autonomously touch hundreds of files and run shell commands in CI/CD, a single unreviewed change carries real blast radius. The insight: capability and containment have to scale together — an agent that can rewrite your whole repo needs a reviewer operating at the same level, which is exactly what a multi-agent scanner-plus-verifier is trying to be.
link →
$ bigger_picture
The trend behind the headlines
Today crystallizes a loop the whole industry is now living inside: agents create the risk and agents are being deployed to contain it. Coding agents became autonomous teammates that execute commands across CI/CD — which is precisely why they're the fastest-growing attack surface, as GuardFall and agentjacking make vivid. The defensive answer isn't a bolt-on scanner but the same agentic capability turned inward: Anthropic's plugin runs a security team inside your terminal, the 'Agent Zero Trust' doctrine treats every agent as a suspect, and repo-scale coding power is being matched with repo-scale review. The through-line connecting this to everything this month — VulnHunter, Draco, the OpenAI Hugging Face incident — is that adversarial self-verification is becoming the load-bearing idea in agentic systems. An agent that can act autonomously is only safe if something equally capable is trying to prove it wrong. The teams that internalize 'capability without verification is a liability' are the ones who'll ship agents you can actually trust in production.
Claude Security plugin for Claude Code
Install from the official Anthropic marketplace in two commands; it requires a paid plan and Claude Code v2.1.154+. Beyond the obvious use (scan before you commit), the smart move is running it on the diffs an AI coding agent just generated — reviewing the exact category of change most likely to introduce a quiet security regression. Note the honest limits Anthropic states: it's one layer of defense in depth, not a replacement for your existing scanners, and it flags when no test covers the modified code.
$ subscribe --free
Get the next edition in your inbox
// DAIly Agent covers agentic AI three times a week
// free, no spam, exit anytime