The problem

On 8 November (US Pacific time) Ryan Dahl, who created Node.js and Deno, posted: “it’s shocking that software engineering has transitioned to 100% AI written in such a short time.” He went on: “It writes C++ better than I ever could, but the problem of making sure it works didn’t magically disappear. we are just shipping enormously more volume at higher quality.” By the time I read it on 11 November it had about 1.84 million views.

That is the part of the job that did not get cheaper. A model can produce a thousand lines in a minute; someone still has to know whether the design was right, whether the cheap model followed the plan, and whether the change opened a hole.

So this week’s open-source picks are four projects that each try to own a piece of that checking. Three of them were on GitHub’s trending pages when I looked, and Google announced the fourth on 7 November. I opened all four on 11 November 2026, around 3 PM Pacific.

What I concluded

All four separate the check from the work in some way, and two of them, EGM and Cloudflare’s skill, state the rule outright: the agent that checks must not be the agent that did the work, and it should start without the author’s context. They differ in when they check:

  1. Before any code exists: review the design.
  2. At handoff: give a cheaper model a plan whose every step has a command and an expected result.
  3. Before release: hunt for vulnerabilities, then have a different agent try to disprove each one.

Pick the one that sits at the stage where your mistakes are most expensive. And treat “fresh context” as a claim to test, not a feature you get by installing a plugin.

Constraints

Anyone comparing these should know:

  • Star counts and commit dates move daily. The numbers below are a snapshot from the GitHub API on 11 November 2026; commit dates are UTC.
  • I read the READMEs, docs and one issue. I did not install or run any of these, so every claim about behaviour is the project’s own.
  • Two of the four have had no commits on main since mid-September. That is not necessarily abandonment for a skill made of Markdown prompts, but it is worth knowing.
  • They solve different problems. The comparison is about where the check sits and how independent it is, not which one is “best”.

The options, and what I traded away

Repo License Stars (11 Nov) Latest commit on main What it checks, and when
google/elephant-goldfish-model Apache-2.0 17,657 11 Nov 2026 The design, before code
shadcn/improve MIT 10,810 12 Sep 2026 The plan and its execution, at handoff
cloudflare/security-audit-skill MIT 70,320 14 Sep 2026 Vulnerabilities, each one challenged by a second agent
openai/codex-security Apache-2.0 11,676 11 Nov 2026 Vulnerabilities in a repo or a diff, plus patches and fix checks

Elephant-Goldfish Model: check the design before anyone writes code. A plugin for Antigravity, Claude Code and Codex. The “elephant” session holds your project context and drafts the specification. “Goldfish” reviewers get the draft and the source it references, without the earlier conversation, and look for unstated assumptions. You resolve the trade-offs and approve the spec before implementation. If your agent cannot create fresh subagents, EGM stops the review instead of running the review in the same context. There is also a drift report that compares design docs with the current code. The README is careful: “A review does not replace tests or human judgment,” and this is “not an officially supported Google product.”

The interesting detail is in its own docs. The support page says reviewer isolation evidence is “narrower” than the install tests. Issue #237, open since 30 October, reports that on Codex the reviewers still receive the project and user AGENTS.md, and on Antigravity the project AGENTS.md and GEMINI.md. The doc says Claude’s reviewer adapters are set to leave out CLAUDE.md, and that for Codex and Antigravity no instruction-file exclusion control is verified. The reporter’s argument is that these files often hold a team’s assumptions (“we always use X”), so a reviewer that starts with them reviews with the author’s priors. EGM’s own advice is to keep stable conventions in those files and write any assumption the Goldfish must challenge as an explicit review criterion.

improve: make the plan carry its own test. A skill from shadcn that audits a codebase with your most capable model and writes plans for cheaper models to execute. It never edits source itself; it only writes to plans/. Each plan step ends with a command and its expected output, plans record the commit they were written against so the executor can check for drift, and they spell out STOP conditions. The README admits that its audit subagents over-report, so the advisor re-reads every cited location before showing you a finding. execute sends a cheaper model into an isolated git worktree, then re-runs every done criterion and reads the diff, with at most two rounds of revision. Merging stays with you. The cost: the last commit on main was 12 September, and the quality of the whole thing rests on how good those gate commands are.

Cloudflare’s security-audit-skill: the finder never confirms its own find. A six-phase audit skill: reconnaissance, hunting, then every candidate goes to a fresh verifier that tries to disprove it. Results are one of three verdicts, confirmed, needs_validation or rejected, and a zero-dependency Node validator checks findings.json against a JSON schema (a second one checks the coverage ledger). The README states the rule plainly: “The agent that checks a finding is never the agent that found it.” It also requires an OS-level sandbox with external networking disabled for anything that builds or runs the target. Two numbers in its docs are worth keeping. In its test runs, a single run found roughly half of the vulnerabilities that repeated runs found in total. And Cloudflare’s own blog says that when they grew this into a fleet scanner over 128 repos, the worst single repo took just over 14 hours, so full scans became a periodic backlog sweep rather than a per-PR check. Every confirmed finding there must ship a proposed patch.

Codex Security: the packaged version. OpenAI’s CLI, TypeScript SDK and GitHub Action. It scans a repo, chosen paths or a Git diff (cs scan . --diff origin/main), validates candidate findings, generates patches and verifies existing fixes, and exports SARIF, JSON or CSV. The weekly Action example sets an estimated $5 limit per scan and reports findings without failing the job; the README notes that requests in progress can go over the limit. It works with OpenAI, Amazon Bedrock, OpenRouter, Fireworks AI and Cheaper Inference; each provider needs its own credentials. Some cyber requests and protected findings need OpenAI’s Trusted Access for Cyber. This repo is the most active of the four; its last commit was a few minutes before I looked.

Evidence

Put Dahl’s problem next to these and a pattern shows up:

  • Each check produces something you can inspect afterwards: a reviewed spec, a plan with commands, a findings.json with verdicts, a saved report. None of them asks you to trust a chat reply that says “looks good”.
  • Where independence is the stated goal (EGM and Cloudflare’s skill), it is also the hardest part to verify. EGM documents its own gap. Cloudflare’s skill gets independence by spawning a new agent, which is only as fresh as the host lets it be. The README doesn’t say whether host instruction files reach that agent.
  • Repetition matters. In Cloudflare’s test runs, one run found about half of what several runs found; Codex Security’s deep mode repeats standard scans and deduplicates the results. A single pass is a sample.
  • Stars don’t line up with any of this. The 70,320-star repo has not changed since September, and the README calls it the single-repo starting point the later system evolved from. The most active of the four is OpenAI’s codex-security; its latest commit landed minutes before I looked.

Counter-arguments worth taking seriously. “Tests already do this”: for behaviour you thought to test, yes. None of these replaces tests, and improve and Cloudflare both lean on the repo’s own test commands. They target the design mistakes and the holes nobody wrote a test for. “A second model has the same blind spots”: partly. That is why the fresh context matters, and why Cloudflare’s blog says different models turn up different bugs. “This is just more tokens”: it is. The question is whether one more pass costs less than the bug, and Cloudflare’s note that extra passes cost about half the first is the closest thing to a number here.

Where this stops being true

For a small change in a codebase you know well, a human review plus tests is usually cheaper and faster. For a prototype you will throw away, design review is overhead. These earn their keep when the author is a model, the reviewer’s time is the scarce thing, and a mistake ships to people who did not write it.

What I would do differently

If I were adding checks to an AI-heavy codebase this month:

Put the first check where a mistake costs the most. For most teams that is the design, before a model writes a thousand lines in the wrong direction.

Make every handoff carry its own pass/fail command, the way improve’s plans do, so the executor doesn’t have to judge its own success.

Run security scans on the diff for every change and a full sweep on a schedule, and expect to run the full one more than once.

Test the “fresh context” claim yourself. Issue #237’s method is simple: plant a marker string in each instruction file and ask the reviewer to list every marker it can see.

Choose by stars last.