Find Every Reason To Dismiss Me
I commissioned an adversarial AI review of my own code — instructed to find every defensible reason to dismiss it. It accused me of not having written the code. That was the most useful thing it could have done.
There is a kind of feedback you cannot get from people who like you, or from people you pay, or from people who have to work with you tomorrow. Everyone in those categories is — reasonably — managing the relationship. The review comes back constructive. The hard thing gets said gently, or it does not get said.
I wanted the version with no relationship to manage. So I built it. I took one of my codebases — liveView, an observability tool — and handed it to Claude with a single instruction: act as a hostile technical reviewer. Find every defensible reason to dismiss this work. Assume the worst about the person who wrote it. Ground every claim in specific code, with file names and line numbers.
I gave it a roleplay frame to push the posture all the way — a reviewer writing to a professor, building a case to remove a student. Ignore the theater; I was never anyone’s student. The frame was just a way to get an adversary that does not soften. What matters is that every finding underneath it points at real lines of real code.
It did not soften.
It Said I Did Not Write It.
The headline finding was that I had not written the code at all.
It is right. That code was AI-generated. I directed it; the model wrote it.
The review treats that as the disqualifying finding — the thing that, if true, means the work cannot be assessed as mine. If you are grading a student on individual engineering capability, fair enough. But that is not the job I do. So I want to take the accusation seriously, and then explain why I published the document that makes it.
“The AI Wrote It” Is Not The Gotcha.
If you hire someone to integrate AI into your systems, and they do not use AI to write code, you have hired the wrong person. The craft is no longer typing. The craft is direction and judgment: deciding what to build, knowing what good output looks like, and — the part that matters — catching the output that only looks good.
The review proves that point against itself. Strip away the authorship drama and look at what else it found.
useEffect with an unstable dependency array — a fresh array created on every render — in two named files, with line numbers: a textbook setup for an infinite re-render loop. A force-directed graph running up to 4.95 million force calculations on the main thread, synchronously, for a 100-node graph. The same helper, isRecord, defined four separate times, each version slightly different. And zero tests beneath heuristic code that infers types from untyped JSON.
None of those are opinions. Each one is true or false, and each one was true. That is not an insult — that is a backlog. A prioritized backlog with file paths attached, which is the single most useful thing a review can hand you.
And here is what the authorship accusation misses: a reviewer that surfaces those three performance bugs is doing exactly what you want done to your systems before they ship. That the reviewer is an AI does not weaken the finding. It means you can run it again tomorrow, on the next codebase, for free.
Hold The Meeting Yourself.
I work mostly with systems where “it works” is not the bar — identity, payments, regulated data, software that fails an audit if it cannot explain itself.
In that world, an adversarial review is not a postmortem. It is a stage in the loop. Before something ships, a reviewer whose entire job is to assume the worst goes through it and writes down what it found. You fix what is real. You document what you are accepting, and why. Then it ships — and when an auditor, a regulator, or an incident review eventually asks the hard question, you already have the answer, because you asked it of yourself first.
Better to hold that meeting yourself. On your own schedule. With a reviewer that never gets tired, never gets political, and works for free.
The Document.
I am publishing the review unedited — including the long section that argues I should be removed from a program I was never in, and the appendix that indexes every flaw by file and line. I am not publishing it because it flatters me. I am publishing it because the willingness to show it is the credential.
AI-generated code is not the risk. Unreviewed code is the risk. The entire discipline lives in the review loop — and building, running, and acting on that loop is most of what I actually do.
Round Two.
Some months after the original review, I commissioned a follow-up — same adversarial posture, much broader scope. The reviewer was pointed at the body of work that has accumulated since: the Campfire substrate, the dual-Arc Vulkan limit-finding, the live homepage, the multi-agent orchestration build, the local-first analysis engine, and the ADRs and constitutions that frame them.
The reviewer stayed in role. The four files it built its strongest dismissals around:
RaidUI/docs/adr/adr-017-honest-placeholder-pattern.md · RaidUI/src/diagnostics/__tests__/classify.test.cjs · campfire/docs/CONSTITUTION.md · www/site/index.html.
My preliminary read is that the dismissals are narrower in scope than the first round. The original critique was structural — about whether the work could be assessed as mine at all. The new critique is about specific claims and where they outrun the receipts. That feels like progress, but the receipts that still matter live in front of paying engagements, not in the constellation. The full curated review will be posted separately. Unedited, as before.