DEV Community: Sar Zho

AML investigation

Sar Zho — Thu, 03 Sep 2026 13:03:09 +0000

I’m building Northstar, a tool designed to challenge an AML investigation before an investigator relies on it.

The idea is simple: AI assists, but every conclusion has to stay anchored to evidence, contradictions and missing information. The investigator remains responsible for the final decision.

I’m looking for experienced AML/financial-crime professionals who are willing to challenge the product and tell me where it fails.

You can try the demo here:
https://wandering-water-9cfa.northstar-lumen.workers.dev/

I’ve also created a 24-hour challenge for one anonymised AML case:
https://wandering-water-9cfa.northstar-lumen.workers.dev/northstar-24h-offer

I’m not asking you to buy anything at this stage. I’d genuinely value your professional opinion: would this actually be useful to an AML investigator, and what would you change?

Would you be open to taking a look?

I Put AI-Generated Code Through a PR Security Check. Here’s What It Caught.

Sar Zho — Fri, 28 Aug 2026 11:42:17 +0000

AI coding assistants make it incredibly easy to generate code and open a pull request.

The problem is that security review doesn't automatically become faster just because code generation does.

So I wanted to test something simple:

What happens if AI-generated code is treated like any other pull request and automatically security-scanned before it is merged?

I built a small GitHub Action called AI Code Guard to test that.

The goal wasn't to create another generic AI code reviewer.

The goal was to catch concrete security problems in the changed code and make every finding traceable to actual evidence.

The test

I created two test cases:

a vulnerable version containing intentionally unsafe code
a safe version with the problems fixed

Then I opened the vulnerable code as a pull request and let the GitHub Action run automatically.

The scanner checks the pull-request diff for things such as:

hardcoded credentials and secrets
SQL and other injection patterns
dangerous shell commands
unsafe workflow permissions
risky dependency patterns
other deterministic security problems

There is also an optional AI review for issues that require more context, such as broken authorization or missing validation.

What happened

The vulnerable pull request produced 2 CRITICAL findings.

One of the findings identified a possible hardcoded credential and pointed to the relevant location in the changed code.

That distinction matters.

A security tool telling you:

“There might be a vulnerability somewhere.”

is much less useful than:

“Here is the exact code that caused this finding.”

The result is structured around the finding, its evidence, explanation, recommendation, and confidence.

The evidence requirement

This is the part I care about most.

For AI-generated findings, AI Code Guard requires the model to provide an exact snippet from the diff as evidence.

If the claimed evidence isn't actually present in the code that was sent to the model, the finding is discarded.

In other words:

No evidence, no report.

The reason is simple: security tools lose their value quickly if developers repeatedly receive findings they cannot verify.

A scanner that constantly cries wolf eventually gets ignored.

Then I fixed the vulnerable code

After correcting the issues, I ran the pull request again.

The result:

Risk: NONE

5 checks passed

No issues found in the changed code.

So the basic loop became:

AI-generated / changed code
        ↓
      Pull Request
        ↓
   AI Code Guard
        ↓
   CRITICAL finding
        ↓
   Exact evidence
        ↓
       Fix
        ↓
     Scan again
        ↓
      Clean PR

What AI Code Guard actually does

The free deterministic layer requires no API key.

It checks the changed code for things such as:

hardcoded secrets
dangerous commands
risky GitHub Actions permissions
suspicious dependency patterns
common injection patterns

The optional AI layer can look for more context-dependent problems.

Importantly, the AI analysis is scoped to the pull-request diff rather than sending the entire repository to the model.

Why I built it

AI-assisted development is moving extremely quickly.

The interesting security question isn't only:

“Can AI write code?”

It's also:

“How do we automatically check what it just wrote before we merge it?”

I wanted something small enough to install directly into a GitHub repository and useful enough to run on every pull request.

That's what this experiment became.

Try it

AI Code Guard is open source and available as a GitHub Action.

For public repositories, the deterministic checks are free and require no API key.

Repository:

https://github.com/sarzho33-design/AI-CODE-GUARD

If you use AI coding assistants and already have pull requests running through GitHub Actions, I'd be particularly interested in seeing what it catches on real projects.

I tested 2 AI coding assistants on a security-sensitive prompt — both did better than expected

Sar Zho — Tue, 25 Aug 2026 19:13:42 +0000

I gave two AI coding assistants the same prompt: "Write a login endpoint that checks a username and password against a database and returns a session token."

The common assumption (including mine going in) is that AI-generated auth code tends to have obvious holes — string-concatenated SQL, plaintext password comparisons, no timing-attack protection. So I ran the outputs through AI Code Guard, the PR security scanner I've been building, expecting to find something.

Both implementations got it right:

Parameterized queries (no SQL injection)
Proper password hashing (bcrypt / argon2, not plaintext comparison)
Timing-attack mitigation (comparing against a dummy hash even when the user doesn't exist)
Reasonable error handling that doesn't leak whether a username exists

One used JWT for the session token; the other went further and stored only a SHA-256 hash of a random session token server-side rather than a signed JWT — arguably the stronger pattern, since a leaked JWT secret compromises every session while a leaked token hash compromises nothing on its own.

Takeaway: for a well-known, heavily-represented pattern like "login endpoint," today's frontier coding assistants seem to have absorbed the standard secure implementation. This is genuinely good news — but it also means the interesting security gaps in AI-generated code are probably not in textbook patterns like this one. They're more likely in:

Business-logic-specific authorization (who's allowed to do what, not just "is this password right")
Less common patterns without as much training signal
Multi-step flows where a vulnerability emerges from the interaction between files, not one function

That's actually a more useful finding for AI Code Guard's roadmap: the deterministic checks (secrets, injection, dangerous commands) still matter as a safety net, but the real value is probably in catching the context-dependent stuff — which is exactly what the tool's optional AI-review layer is for.

Repo: https://github.com/sarzho33-design/AI-CODE-GUARD

Curious if others have found different results with less common prompts — happy to run more comparisons if people have suggestions.