I review code for other people. As a fractional CTO I have read pull requests across Unity, React Native, Next.js and a GraphQL dashboard, and I recently wrote down the order I review in: description first, then the file list, then most of my attention on four things. Data that cannot be undone, contracts other code depends on, failure paths, and anything that ships somewhere slow to roll back.

Then I opened GitHub on my own products.

VoiceDash (white-label client portals for Retell voice agents) has 25 pull requests. Upwork Scout (AI-matched Upwork job alerts) has 3. That is 28 pull requests across two repos I run alone, and every single one has zero reviews. Of course it does. I am the only developer. I open the PR, I merge the PR, and Vercel deploys it.

So instead of pretending a solo dev gets a second pair of eyes, I took my own checklist and ran it over my own history. Here is what it found, including the bits that are embarrassing.

Step one: read the description first

My first comment on anyone else's pull request with no description is "what is this for?" My own early PRs would have earned it seven times.

VoiceDash PRs #1 through #7 are all titled Dev. Six have an empty body; #7 has twelve characters. The commits underneath read like this:

177be2a lots of stuff a6dbd24 lots of. more updates 8079cd9 mroe updates f6a8c96 more updates and fixes 

PR #1 was 2,668 added lines across 43 files. Nobody, including me three weeks later, can review that.

The good news is that this is the one habit that actually changed. From PR #11 onward every PR has a real description, and the commit messages turned into small bug reports. This is from September:

Stripe: only treat a confirmed resource_missing as "not in this account" The account-migration helper caught every error, so a network blip, a rate limit or a Stripe 5xx during checkout would be read as "this customer does not exist here". It would then clear stripeCustomerId, detaching a paying customer from their billing record and handing them a second trial. 

Problem, cause, fix, blast radius. When you are your own reviewer, the description is the review. Writing "what happens to a paying customer if this is wrong" forces the question a reviewer would have asked, and it is the only reliable way I have found to step outside my own head.

Step two: look at what it touches, before how

The file list is where I decide whether a review is a skim or a careful read. Schema, auth, payments, third-party calls: slow read.

My biggest PR breaks this step entirely. VoiceDash #23, "Client billing through the agency's own Stripe account", is 6,279 added lines across 89 files. It touches the schema, Stripe Connect, webhooks, a cron job, client lockout logic and the billing UI. It is the exact thing I tell clients to split into a refactor PR and a behaviour PR, and then into smaller behaviour PRs.

What I did instead was not review. It was test: an 87-item hand-test plan in a Stripe sandbox with test clocks for retries and installments. 80 passed, 1 failed (a phone layout issue, split out as its own task), 6 were skipped (custom-domain sign-in and checks that could only run on release day). Then a real-money test on the preview with a live UK account.

I think that was the right call for a solo dev shipping a feature that only makes sense whole. But I want to be honest that it is a substitute for review, not review. A test plan checks the paths I thought of. A reviewer's job is the paths I did not.

Step three: data that cannot be undone

This is where I spend the most time on client code, so I gave it the most time here. VoiceDash has 133 commits on main and six Prisma migrations. I lined up every commit that touched schema.prisma against every commit that touched prisma/migrations.

Every schema change from September and October came with its own migration. One from April did not:

ae0f559 Remove phone numbers feature entirely Deleted all phone-numbers pages, API routes, components, and Prisma model. 

The PhoneNumber model is gone from the schema. The init migration still creates the PhoneNumber table, with foreign keys to Agent and Client, and no later migration drops it. So anyone following the README (npx prisma migrate deploy) on a fresh database gets a table the code has never heard of. What production looks like depends on what I did by hand in April, which I can no longer prove from the repo. That is the actual problem: the history stopped being the truth.

It is also a commit I made with an AI coding tool, and it is a textbook example of my own "unexplained changes" rule. "Remove the feature" was the ask. Deleting a model is a database change wearing a refactor's clothes.

The contrast is a migration from September, which I am genuinely happy with. Making calls unique per agent instead of globally needed an index swap on a live table:

-- Written to be re-runnable: it is applied by hand to the live database. CREATE UNIQUE INDEX IF NOT EXISTS "Conversation_agentId_platformCallId_key" ON "Conversation"("agentId", "platformCallId"); CREATE INDEX IF NOT EXISTS "Conversation_platformCallId_idx" ON "Conversation"("platformCallId"); DROP INDEX IF EXISTS "Conversation_platformCallId_key"; UPDATE "Agent" SET "callsSyncedUntil" = NULL; 

The commit message says it ran in two steps around the deploy: new indexes first, the old unique index dropped only once no running code depended on it. IF NOT EXISTS everywhere so a half-applied run can be repeated. That is what a reviewer would have asked for, and I only did it because I had been burned enough to ask myself.

Step four: failure paths

The pattern I look hardest for in review is a catch that turns an error into a confident default. The Stripe commit above is that pattern exactly, in my own code:

// before (simplified) } catch { // any error at all was treated as "customer is not in this account" } 

A rate limit during checkout would have cleared a paying customer's Stripe ID and handed them a second trial. The fix only treats an explicit resource_missing as "not here" and rethrows everything else.

The commit before it was the same family. Stripe's newer API versions moved current_period_end from the subscription onto its items. My code read it off the subscription, got undefined, wrote new Date(NaN) into a non-nullable column, and the upsert threw after the money side had already succeeded. Checkout could complete in Stripe and still drop the customer back on the subscribe page.

Both were found after shipping, not in a review. I wrote about the Stripe account move that surfaced them separately, and about another silent failure in a cron job that still exists. Both of those are a reviewer's catch that nobody was there to make.

Step five: things slow to roll back

A Vercel deploy reverts in a minute. A database index, a Stripe webhook pointing at the wrong URL, or a live Connect setting does not.

PR #23 handled this better than most of my work: its description has a release checklist. Migration applied with a backup first, live Connect enabled, production webhook secret set, and "turn off the temporary live webhook that points at the dev preview". When it merged, the last two boxes were still unchecked. They may well have been done afterwards. The point is that the PR was merged with the description saying they were not, and nothing stopped it.

What there is instead of a reviewer

Neither repo runs anything in CI that would catch the above. VoiceDash's only GitHub workflow keeps the Supabase database awake. Upwork Scout's only workflow pings the job scanner. Upwork Scout has a 105-line smoke test script that nothing runs automatically. The closest thing I have to CI is that next build on a Vercel preview fails on a type error.

So here is what I am adding, none of which has shipped yet:

  1. A PR template with four questions, the same four from my checklist. Does this write, migrate or delete data? Does it change something another client reads? What happens when the third-party call fails? How do I turn it off without a deploy? It takes a minute and it is the reviewer I do not have.
  2. A CI check that the schema and the migrations folder agree, using prisma migrate diff between the two and failing on any difference. That one check would have caught the PhoneNumber drift on the day it happened.
  3. Typecheck, lint and the smoke script on every PR, so the preview build is not the only gate.
  4. Self-review in the GitHub diff view before merging, reading it as if a contractor sent it. Most of what I find in other people's PRs is visible in that view. Mine too.

The lesson for me was not "solo devs need code review". You cannot get it, and pretending a second account approving your PR is review is worse than nothing. The lesson is that review is a set of questions, and a solo dev can still be forced to answer them, by a template, by a CI check, or by a commit message that has to explain what breaks if it is wrong.

The original, longer version for teams (review order, AI-written code, keeping PRs small) is on my site: Code review on a small team: what I actually check.

If you are the only developer on your product, what do you use in place of a reviewer? I would especially like to hear from anyone who has made a schema drift check work with Prisma in CI without a shadow database getting in the way.