ShieldProbe Fix

The IDE extension that saw every attack on your app.

Fix pulls Assess findings into VS Code with the full pentest-agent log — hundreds of thousands of attack attempts, payloads, and reasoning traces from your engagement. That context is why its patches are sharper than Copilot, Cursor, or Claude Code on a finding summary.

Visual Studio Code
1 vulnerability detected
index.ts
userController.ts
database.ts
Vulnerable CodeSQL Injection
41424344454647
async getUserById(id: string) {
const query = `SELECT * FROM users
WHERE id = '${id}'`;
const result = await db.query(query);
return result.rows[0];
}
AI Fix
AI-Generated FixVerified Safe
41424344454647
async getUserById(id: string) {
const query = `SELECT * FROM users
WHERE id = $1`;
const result = await db.query(query, [id]);
return result.rows[0];
}
Fix uses parameterized queries to prevent SQL injection
feature/user-auth TypeScript
Fix Verified Ln 42, Col 15
$time_to_fixMinutes
$report_reading0
$pr_creation1-Click
The differentiator

Why Fix produces sharper patches than Copilot on a finding summary

Every Assess engagement generates a pentest-agent log: the exact requests the AI tried, the responses it got back, the paths it pivoted through, the hypotheses it tested and discarded. Fix loads that log as code-context when it drafts the patch. Nothing else does this.

Generic code assistant
input:"SQL injection on /api/users?id — use parameterized queries."

Produces a textbook fix for the class of vulnerability. Doesn't know which other routes share this helper, whether the ORM already has an escape hook, or what the attacker actually did to get here.

Fix — with pentest-agent context
input: Full attack transcript. The 47 payloads the agent tried. The exact parameter it tampered with. The adjacent endpoints it probed. The finding, the proof, and every byte of back-and-forth.

Produces a patch that matches your code's actual shape: uses the ORM helper you already import three files over, catches the adjacent routes that share the same query builder, and respects your existing validation layer.

How Fix actually works

Four steps. Then a candidate PR sitting in your review queue.

1

Install the IDE extension

VS Code live. Visual Studio in beta. Drop-in install — the extension authenticates against your ShieldProbe tenant and pulls your Assess findings into the editor.

2

Findings materialize at the right file and line

Each finding opens in the IDE with the exact file, line, and payload that proved it. Reproducible evidence sits next to the code, not buried in a PDF in Jira.

3

In-code research with full agent context

The AI drafts a patch using the pentest-agent log as context. It traces callers and callees, checks your existing imports and helpers, and writes code that fits your style.

4

One-click candidate PR

The patch opens as a PR in your repo. Your CI runs. Your reviewers review. Your tests gate. Nothing is bypassed, nothing is auto-merged — the PR is just there, ready for humans.

Case · Business-logic patch

Fix does what Copilot can't: patches a logic flaw from the attack transcript

The banking-app negative-number withdraw (the same finding Defend neutralizes at runtime). Here's the permanent code fix Fix drafts — and why it could only produce it with the pentest-agent log.

Context Fix sees
  • The exact POST the agent sent: { amount: -50000 }
  • The server's response: 200 OK, balance increased
  • Four adjacent endpoints (/transfer, /refund, /credit, /adjust) that share the same sign-trusting handler
  • Your existing validateAmount() helper in lib/validators.ts
// controllers/transactions.ts  —  candidate patch
// Generated by ShieldProbe Fix · references 4 adjacent routes

import { validateAmount } from '@/lib/validators';

export async function withdraw(req, res) {
  const { account, amount } = req.body;

+ const parsed = validateAmount(amount, { min: 0.01, max: LIMITS.withdraw });
+ if (!parsed.ok) return res.status(400).json({ error: parsed.reason });

- if (balance < amount) return res.status(402).send();
+ if (balance < parsed.value) return res.status(402).send();

  // ... existing logic, now safe against negative/oversized amounts
}

// Fix also drafts companion patches for:
//   controllers/transfer.ts, refund.ts, credit.ts, adjust.ts

Reuses your helper. Catches every sibling route that shares the flaw. Preserves your existing 402 response shape. A generic assistant pointed at a finding summary would only patch the one file — and might even reinvent the validator.

What Fix will not do

Trust-by-design. Here's what we refuse, on purpose.

Never auto-merges

Every patch is a candidate PR. Your reviewers, your CI, your test suite, your merge rules — untouched.

Doesn't bypass your review process

Fix opens PRs the same way a human engineer does. Required approvers, branch protection, signed commits — all respected.

Doesn't touch secrets or infra

No credential generation, no infrastructure-as-code rewrites, no cloud API calls. Application code only.

Doesn't ship client data to third parties

The reasoning engine runs on ManticoreAI infrastructure. We don't send your code to OpenAI or Anthropic to draft patches.

IDE and language coverage

Honest today vs. roadmap. No surprises.

IDE support

Live VS Code
Beta Visual Studio
Roadmap JetBrains (IntelliJ, PyCharm, WebStorm)
Roadmap Neovim / Cursor plugin

Language coverage

Live TypeScript · JavaScript · Python · Go · Java
Live C# · Ruby · PHP
Beta Rust · Kotlin
Roadmap Swift · Elixir

Source-control hooks

Live GitHub (PRs, branch protection, checks)
Live Azure DevOps
Roadmap GitLab · Bitbucket

The remediation workflow, before and after

The cost of finding a vulnerability is only the first cost. Remediation is where timelines actually break.

Without Fix

1

Security receives the pentest report (PDF)

2

Security triages, writes Jira tickets

3

Developer reads ticket; searches for the file, the call path, the context

4

Developer interprets the vulnerability from prose

5

Developer writes fix from scratch; misses adjacent routes

6

Requests retest; waits for schedule

30–90 days typical

With Fix

1

Developer opens VS Code; findings are at the line with full attack transcript

2

Reviews the candidate patch — informed by every request the agent ran

3

One-click PR; adjacent-route patches included by default

4

CI runs; reviewers approve; merge; Assess deterministic replay auto-verifies

Minutes to hours
Why Fix finishes faster: the developer isn't reading a PDF. They're reviewing code that was drafted with knowledge of the exact exploit that proved the flaw.

Close the remediation loop

Fix ships bundled with Assess. Runtime protection via Defend holds the line while developers land the code fix.