# AI Vulnerability Scanner on Claude Code: CodeCrucible SAST

> Run an AI SAST / AI vulnerability scanner on a Claude Code microVM: Block CodeCrucible, dry-run cost gate, SARIF out. You verify findings. No free trial.

- Published: 2026-07-29 · Updated: 2026-07-29 · jurniti
- Canonical: https://www.jurniti.com/blog/ai-vulnerability-scanner-codecrucible-template

Search **ai vulnerability scanner**.

You get listicles. Vendor PDFs. Blog posts that turn LLMs into a second-pass filter on Semgrep noise.

Almost nobody hands you a **running scanner seat**: whole-repo AI SAST, cost gate on the dry-run, SARIF on disk, Claude Code already on the box - and **you** still decide what is real.

That seat is the CodeCrucible LLM SAST template on jurniti.

## What buyers mean by "AI vulnerability scanner"

They are not asking for another marketing synonym for classic static application security testing.

They want:

1. Coverage when **no rule exists** yet  
2. Cross-file reasoning without hand-written taint configs for every framework  
3. Output that plugs into **GitHub Code Scanning** (SARIF)  
4. A cost story - scans that can spend real model dollars without a surprise bill  

DataForSEO (US, 2026-07-29) puts commercial heat on the category: **`ai vulnerability scanner` ~110/mo**, **`ai sast` ~70/mo**, with **`claude code security scan` ~30/mo at LOW competition**. Head term **`sast` is ~5,400/mo** - that SERP is Semgrep/Checkmarx territory. This page ranks the **AI/LLM SAST cluster** and CTAs into a forkable template, not a 5,400/mo head-on war.

## The product: AI SAST you can fork

Block published [CodeCrucible](https://github.com/block/codecrucible) as a **blueprint for LLM-driven SAST** - whole-repo packing, analysis + audit, SARIF out, explicit cost controls. The essay is the design; the CLI is the reference implementation.

jurniti's template is the **operator pack**:

| You get | Why it matters |
| --- | --- |
| `~/.agents/bin/codecrucible` | Built binary on a Claude Code microVM (persist-safe) |
| Prompt sets under `~/.agents/codecrucible/prompts/` | default / exploit-proof / carlini-style sets from upstream |
| Operator skill | Dry-run first, bound `--max-cost`, human triage |
| Tiny sample app | Prove dry-run before you burn tokens on a monorepo |

You bring the model key. You own the box. You own the merge button.

## Whole-repo is the point

Most "AI SAST" products still put a traditional analyzer first. The LLM validates a snippet the engine already nominated.

CodeCrucible's blueprint **flips that**: the model does primary analysis over packed repository context. That is expensive in tokens. It is also how you catch classes of bugs that never fire a Semgrep rule.

If your mental model of an AI vulnerability scanner is "chat with a file," this is a different product. If your mental model is "pipeline that emits SARIF with a budget," you are in the right place.

## False positives still need a human

Industry writing in 2025-2026 is blunt: raw model dumps flag half a codebase; hybrid audit passes cut noise; developers mute tools above ~10-15% false positives.

So this template is **not** lights-out auto-remediation.

The operator skill forces:

- `--dry-run` before real spend  
- `--max-cost` on exploratory scans  
- SARIF as **evidence to verify in source**  
- **No auto-merge**  

If you want a bot that opens "fix" PRs without reading the code, leave now. If you want AppSec-grade process on a microVM, stay.

## Undeniable demo (copy-paste)

After fork and login:

```text
export PATH="$HOME/.agents/bin:$PATH"
codecrucible scan ~/.agents/codecrucible/samples/tiny-app --dry-run
export ANTHROPIC_API_KEY=…   # or Claude Code login - never commit the value
codecrucible scan /path/to/repo --provider anthropic \
  --prompts-dir "$HOME/.agents/codecrucible/prompts/default" \
  --output "$HOME/scans/results.sarif" --max-cost 25
```

Open the SARIF. Jump to the top finding. Confirm or reject. Draft triage only.

That is a **claude code security scan** that actually produces pipeline artifacts - not a vibes review in a chat window.

## Semgrep alternative? Kind of. Not really.

People search **semgrep alternative** (~30/mo) when rules hurt.

CodeCrucible does not replace your rule engine overnight. It answers a different question: **what does the model find when the whole repo fits the context budget?** Many teams will keep Semgrep/CodeQL for CI gates and use AI SAST for deep passes. This template is the deep pass, on a box you control, with BYOK spend.

## Isolation is separate from scanning

We already write about **Claude Code security** as runtime isolation (Firecracker microVM vs shared kernel). That is a different search intent.

This post is **scanning the application**, not securing the agent's host. You still want both: a microVM boundary **and** an AI vulnerability scanner that does not pretend model output is ground truth.

## Pricing honesty

- Plans start on paid jurniti seats (see pricing).  
- **No free trial. No free tier.** First purchase: 30-day money-back.  
- Model tokens are **your** bill (BYOK).  
- Dry-run estimates input cost; real scans also bill completions and audit phases.

## Who this is for

- AppSec and eng leads hunting an **AI SAST** path that ends in SARIF  
- Teams evaluating LLM-driven whole-repo analysis after reading Block's blueprint  
- Claude Code users who want a **security scan** workflow on a dedicated box  

## Who this is not for

- Auto-merge security bots  
- "Zero token budget" scanners  
- Anyone who treats a model finding as a CVE without reading the code  

## Provenance

- [block/codecrucible](https://github.com/block/codecrucible)  
- [CodeCrucible: A blueprint for LLM-driven SAST](https://engineering.block.xyz/blog/codecrucible-a-blueprint-for-llm-driven-sast)  
- Demand signal: [jack on X](https://x.com/jack/status/2082358678498246935)  
- Keyword volume: DataForSEO US 2026-07-29 (`docs/seo/research/2026-07-29-codecrucible-llm-sast-keywords.md`)  

Fork the template. Run dry-run. Bound the cost. Verify the finding. Ship the fix yourself.

## Frequently asked questions

### What is an AI vulnerability scanner?

A tool that uses large language models (alone or with static analysis) to find security defects in source code. Unlike classic SAST, the model can reason across files without a hand-written rule for every CWE. Output is still evidence for a human - not a CVE verdict.

### What is AI SAST?

AI SAST is static application security testing driven by LLMs - packing code into model context, scoring findings, and often emitting SARIF for GitHub Code Scanning. Block's CodeCrucible is one open blueprint for whole-repo LLM-driven SAST.

### What does the jurniti CodeCrucible LLM SAST template do?

It is a public Claude Code template. Fork it and you get a built codecrucible binary under ~/.agents/bin, Block prompt sets, and an operator skill that forces dry-run, --max-cost, SARIF output, and human triage. Model keys are BYOK.

### Is there a free trial?

No free trial and no free tier. Forking provisions a paid plan. The first purchase includes a 30-day money-back guarantee. Model token spend is yours.

### Does the agent auto-merge security fixes?

No. Findings are drafted for you. You verify every hit in source and you own merge. Lights-out auto-merge is out of scope.

### How is this different from Semgrep or CodeQL?

Classic tools nominate with rules and dataflow engines. CodeCrucible-style AI SAST treats the model as the primary analyzer over packed whole-repo context, then audits and emits SARIF. Many teams still want both - this template is the LLM path on a microVM you own.

### What keys do I need?

A model key for the provider you choose (for example ANTHROPIC_API_KEY or Claude Code login), optional OPENAI_API_KEY / GOOGLE_API_KEY / Databricks credentials for multi-phase scans, and optional GH_TOKEN if you want draft GitHub triage notes.