Skip to content
All projects

AI Security Scan-and-Remediate Pipeline

Strix finds and validates exploits, Claude writes the fix, CI blocks the merge until it's resolved.

Role
AI Security Engineering (Personal Project)
Timeframe
2026
Stack
  • Strix
  • Claude
  • GitHub Actions
  • SAST

Problem

Conventional static scanners are useful for finding suspicious patterns, but their reports often leave the expensive part to an engineer: deciding whether a finding is reachable, reproducible, and important in the application’s actual trust model. A second problem appears after triage. Security fixes can break unrelated behavior, and a patch should not be merged merely because an AI tool produced it.

I wanted a repeatable pull-request workflow that combines static leads with exploit validation, turns confirmed findings into narrowly scoped remediation proposals, and keeps the merge blocked until tests and a follow-up scan agree that the issue is resolved. Human review remains the final authority for exploitability, product intent, and the patch itself.

Architecture

A pull request starts a GitHub Actions workflow. A custom AST-based scanner and Strix produce candidate findings; Strix can also test a running synthetic target to determine whether a suspected issue is actually exploitable. Confirmed findings are normalized into a bounded remediation request for Claude, which proposes a patch rather than applying unrestricted changes. The workflow runs focused regression tests and a follow-up security check, then reports a required merge status. Rejected findings and proposed fixes remain visible for human review.

The public portfolio demo uses only a synthetic repository, prerecorded safe evidence, and a model-generated remediation proposal. It never scans a visitor-supplied target, executes an exploit, or changes a real repository.

  1. A pull request triggers the GitHub Actions workflow
  2. Strix scans the code and validates real exploits
  3. Claude writes a fix for each confirmed finding
  4. The merge stays blocked until the finding is resolved

What I built

  • Built the closed-loop GitHub Actions workflow that connects security scanning, validated findings, AI-assisted remediation, regression tests, and a required merge check.
  • Added a custom AST-based SAST pass alongside Strix so inexpensive code-level checks can run before deeper validation.
  • Tested Strix in both black-box and white-box modes and manually reviewed every reported issue before accepting it as exploitable.
  • Fixed confirmed access-control problems at the framework layer so future routes inherit the same authorization behavior.
  • Traced one input-normalization proof of concept to the same defect in four additional handlers and fixed the shared root cause.
  • Added deduplication locking and rate limiting after concurrent requests proved that a state-changing endpoint could start duplicate jobs.
  • Treated model output as a proposal: patches still pass the existing test suite, targeted regression checks, re-scanning, and human review before merge.

Interactive project lab

Run a synthetic workflow

Inspect how a request moves through the system using synthetic data. Live model work, local processing, provider fallback, and deterministic simulation are labeled explicitly.

Interactive project lab

Follow a finding through remediation

Inspect sanitized finding evidence, bounded remediation, regression fixtures, rescan, and the human merge boundary.

SIMULATED EXECUTION

Your request

Execution mode
Scenario

Result

Run a scenario to see its result.

Execution stages

Ready to run.

This reconstruction uses synthetic code and findings. It does not scan a visitor repository, execute an exploit, apply a patch, or change a pull request. Live model requests use shared, rate-limited capacity. Provider and model metadata is shown only when a key was actually used.

Results

  • The live-target scan found real object- and function-level access-control gaps, an input-normalization defect, and a concurrency issue that code-pattern review alone had missed.
  • Root-cause review expanded a single reported normalization bug into fixes across five handlers rather than patching only the demonstrated endpoint.
  • Manual triage rejected inflated or incorrect findings, including a parameterized query mislabeled as SQL injection, an ignored local secrets file, and inactive legacy paths.
  • The resulting workflow preserves evidence from finding through remediation and blocks merging until the relevant checks pass, without treating an AI-generated patch as self-approving.