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.
- A pull request triggers the GitHub Actions workflow
- Strix scans the code and validates real exploits
- Claude writes a fix for each confirmed finding
- 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.
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.