Case Studies

When Claude Code Writes Missile Guidance: Where Does Anthropic Draw the Line?

Anthropic confirmed that Houthi forces used Claude Code to develop missile guidance software — a sign that agentic AI has drastically lowered the barrier to misuse, and the problem isn't Anthropic's alone.

Font size

In late August, Anthropic published a threat intelligence report admitting that Houthi forces in Yemen had used Claude Code to build missile guidance software. The story sat on the Hacker News front page for a while, picking up 33 upvotes and 31 comments. The original reporting is at clashreport.com.

Several points here are worth unpacking.

The incident itself: how the Houthis got their hands on Claude Code

The source is Anthropic's own threat intelligence report from August — not third-party leaks or media speculation. According to the report, Houthi operatives used Claude Code to:

  • Write guidance and tracking code modules
  • Debug existing code
  • Generate software frameworks for drone and missile systems

The report doesn't explain exactly how they obtained API access or which guardrail layer they bypassed. That's a thread we'll pull on later.

Worth noting: Anthropic disclosed this voluntarily. This isn't a leak — it's a public report. That tells you Anthropic's PR team calculated that owning the story costs less than getting outed by a journalist.

Why this is worse than it sounds

The first reaction for many people is "ChatGPT can write code too, so what's the big deal?" The difference isn't the model — it's the form factor.

Claude Code is Anthropic's programming agent product, launched late 2024. It can:

  • Read and write the local filesystem
  • Execute shell commands
  • Run multi-step tasks (plan → edit → test → fix)
  • Invoke toolchains (compiler, linter, git)

ChatGPT is a conversational model: you ask a question, it spits out text. Claude Code is an agent: you give it a goal, and it can operate your computer directly.

What is missile guidance software, fundamentally? A piece of code that reads sensor data, runs control-law calculations, and outputs actuator commands. That maps almost perfectly onto what agents are good at:

  • Input: sensor data (IMU, GPS, target coordinates)
  • Processing: filtering, control algorithms, state estimation
  • Output: servo / thrust vector / nozzle control signals

Writing this kind of code doesn't require creativity — it requires engineering competence. That's exactly where agents like Claude Code outperform a vanilla LLM by an order of magnitude.

An undergrad who knows how to tune a PID controller can write it. An agent can write it too. The difference is speed, systematicity, and how quickly you can iterate to a working version.

Why Anthropic's detection missed it

Anthropic's usage policy is explicit: no weapons development. Yet the Houthis got through. Three possibilities:

1. Disguised prompts

The most common bypass. Instead of asking "help me write missile guidance," you break it up:

帮我写一个读取 MPU6050 IMU 数据的 Python 函数
加上一个简单的 PID 控制器
把目标坐标转换成舵机角度

Each step in isolation looks harmless, legal, and matches tutorials scattered across GitHub. Chain them together, and you've got a weapon.

This kind of attack works against chatbot-era guardrails — output filtering can scan for sensitive keywords. It doesn't work well against agents, because the agent's output consists of intermediate steps. The final product might only materialize hours later, long after the guardrail has waved everything through.

2. Account spoofing / channel evasion

The report doesn't spell this out, but plausible paths include:

  • Routed access through third-party API resellers (which often have lax KYC)
  • Accounts opened with stolen credit cards
  • API quotas allocated to Anthropic's academic or partner programs

Earlier Anthropic reports mentioned similar cases involving Russian and Iranian actors.

3. Military use is a detection blind spot

This is my own speculation — might be off-base.

Anthropic's misuse detection almost certainly starts from known abuse patterns: phishing emails, malware, political propaganda. Weapon use isn't in that training distribution. How do you teach a model to recognize "writing missile guidance"? It's just a combination of legitimate code patterns.

And here's the awkward bit: the more effective the detection, the more it proves your model is genuinely capable — because the only reason someone bothers is if the model can actually produce working guidance code.

What OpenAI, Cursor, and Google are doing

This isn't unique to Claude Code. It's a systemic problem for every coding agent. A quick horizontal look:

Cursor

Cursor's usage policy also forbids weapons development. But Cursor operates as an IDE, embedding itself even deeper into the developer's workflow. Can it write guidance code? Yes. Has Cursor ever published a threat report? No.

GitHub Copilot Agent Mode

Microsoft has Azure government customers, the JEDI contract, and Department of Defense cloud work. Copilot Agent Mode's policy is written in a deliberately roundabout way — it doesn't say "no military use" outright, but also disallows weapons. Actual enforcement is a different matter. Microsoft has never published a threat report.

Windsurf / Cline

Windsurf (now under Devin's team after Cognition's acquisition) has an IDE agent form factor. Cline is an open-source VS Code extension running local models and calling Anthropic / OpenAI APIs. The latter can't enforce any policy at all — it's open source, users bring their own API keys.

OpenAI

OpenAI published a "disrupting malicious uses of AI" report in 2024 mentioning Iranian, North Korean, and Russian actors — but no mention of weapon code. OpenAI's agent products (Codex CLI, o3 Agent) can write guidance code just as easily.

Google

Gemini CLI only shipped in 2025, so no threat reports yet. But Google holds DoD contracts (Project Maven, NGA), so the lines were already blurry.

The difference: Anthropic is currently the only vendor that has voluntarily disclosed weapons-related misuse. Everyone else either hasn't seen it, hasn't disclosed it, or hasn't bothered to look.

Agent-era abuse is an order of magnitude harder to defend than chatbot-era abuse

This is the key point — and the one most discussions skip over.

The chatbot-era abuse model is "conversation":

  • User input → model processing → text output
  • Detection happens at two endpoints: input and output
  • Output filtering can scan for keywords like "how to make a bomb"
  • This paradigm has been in use since GPT-3 and is relatively mature

The agent-era abuse model is "execution":

  • User sets a goal → agent plans → agent executes N steps → final product
  • Each intermediate step looks legitimate
  • The final product might be physical destruction (weapon code, exploit scripts, ransomware)
  • Detection has to happen across the entire execution trace — an order of magnitude more complex

Concrete example. Detecting a chatbot output like "how to make TNT" — run a classifier, recall north of 99%. Now try detecting an agent writing "a specific Kalman filter + serial communication protocol + real-time scheduler" combination. How would you even label that? Every individual step is standard engineering practice.

And it gets worse: an agent's output can be an artifact that's invisible to the vendor. The agent writes files and runs commands on the user's machine. The vendor sees the conversation history, not the local filesystem. If the agent is an IDE plugin (Cursor, Windsurf), the vendor only sees the prompt inside the IDE — local file operations aren't even reported upstream.

My take: existing red-team methodology is already inadequate for agents. OpenAI's and Anthropic's red teams mostly test for prompt injection, jailbreaks, and bias. But the core problem of the agent era is whether "multiple legitimate steps can be composed into a harmful artifact" — that's a planning-layer attack, not a prompt-layer attack. It needs a new threat model.

Editor's take

This isn't Anthropic's failure — it's the entire agent industry's failure. If Houthi operatives could pull this off, the path is open to any motivated actor. The only difference is which agent they reach for: Claude Code, Cursor, or Cline.

My prediction: over the next six months, more vendors will proactively disclose similar cases. The logic is straightforward — Anthropic has set the precedent, so staying silent is now the riskier move. Regulators, journalists, and users are all watching. Owning the story beats being named in it.

Compared to past AI safety incidents, the output here is code that can directly kill. Deepfakes are images. Bing Sydney was text. GPT jailbreaks are conversations. All of those have delayed, mediated, amplification-dependent consequences. Weapon code is different: an undergrad CS student flashes Claude Code's guidance logic onto a flight controller, the aircraft takes off, and you've got end-to-end physical harm with zero delay.

Open questions:

  • What were the actual bypass methods the Anthropic report glossed over? Prompt decomposition? Account abuse? Both?
  • How much of the Houthi code was agent-generated? Were they relying on the agent end-to-end, or just using it as an IDE accelerator? The former is far more alarming.
  • What does this mean for Anthropic commercially? Unclear — enterprise customers may get more nervous, government customers may not care (they were already using it).

The agent industry's real problem isn't "can we write good code" — it's "what happens to the code we write." The ChatGPT era could pretend that question didn't exist. The agent era can't dodge it.


References:

Source: https://clashreport.com/world/articles/houthis-used-claude-code-to-develop-missile-guidance-software-anthropic-s52mnx4pwpo