When an investor's engineer reviews a codebase, most of what they write down is ordinary. A missing test, an outdated library, a query that will be slow at ten times the data. Those get priced in. Every early-stage codebase has a list like that, and a reviewer who finds nothing on it isn't looking.
A red flag is a different kind of finding. It's the one that makes the investor go back over everything else they've been told. Across the reviews I've done this year, paid code reviews, free QA passes, open-source security reviews, and my own product, the red flags have had the same shape: the product says one thing, and the code does another.
A promise the code doesn't keep
Every product makes claims. The pricing page says the free plan has a limit. The settings screen says a post can be private. The permissions screen says a key can only reach the accounts it's been granted. The report says its totals include every record.
A reviewer reads those claims first, then reads the code that's supposed to back them up. Not the screen that shows the setting: the path that writes the data. An ordinary finding says "this could be better." A red flag says "this isn't true."
That distinction matters more than severity. A slow query can be expensive and still be ordinary, because nobody promised it would be fast. A small leak in a privacy setting is a red flag, because somebody did promise.
A limit that one path skips
A CRM in closed beta capped its free plan at 50 records. Creating a record at the limit was blocked, exactly as designed. Restoring deleted records from the recycle bin didn't check the limit at all. I restored a few and the account sat at 58. (The CRM case study has the rest.)
The limit is what separates the free plan from the paid one, so it's part of the business model. And a limit that holds on one path but not the one next to it is usually a sign the check was added where someone asked for it, on the create screen, instead of where the data is written. The next path someone adds, an import, an API, a merge, will probably skip it too.
I've found the same shape in my own product. In Klass Personal OS, an API key is supposed to reach a storage account only if the account is in the key's grants. A key without that grant could still reach the account through the storage tools and the web API. The fix wasn't to patch each route; it was to authorize at the one shared point where every storage action selects its account. Before the fix, the new tests covered seven providers across seven actions, and all 49 combinations failed. That's the evidence that the tests actually reached the defect, not just that they passed afterward.
Filtering the Menu Is Not Enforcement is a third version of it: actions hidden from an AI agent's menu could still run if the agent named them.
A setting that doesn't hold
In a community app, I created two posts, choosing Private both times. One saved as private. The other saved as public, with no error and no warning to the user. (The beverage app case study has the details.)
In an open-source app I reviewed, the user had to approve each new device before it could connect. Connecting through the app's relay server skipped that approval. The maintainer fixed it in a public release.
Neither one needed a sophisticated attacker. The first needed someone to use the app twice. The second needed someone to read how the relay worked. Both contradict the one thing the setting exists to do, and that's why a reviewer would flag them: if this promise doesn't hold, which other ones don't?
Results that are quietly wrong
Some of the most serious findings I've written up didn't involve security at all.
In a paid code review of a CRM, long lists were read in batches and stopped at about 5,000 records. When the cutoff hit, the code wrote one line to a log nobody reads and carried on. Exports, reports, totals, and search all sat on top of it. A large report even showed a note saying its totals included every record, which stops being true past 5,000. The AI coding tool that wrote the code had added the cutoff on its own, and nobody knew it was there. (That case study covers where it reached.)
A site listing public bid opportunities had its real data source blocked in the browser. Instead of an error, it quietly fell back to a secondary source plus bids written into the code, and showed the result as the live feed, including due dates thousands of years in the future. (That one is written up too.)
A developer platform let you store secrets for your app. Adding a secret with a name already in use replaced the stored value and said "Saved." For a store of credentials, a success message on top of lost data is about as bad as it gets. (The team had already fixed it by the time they replied.)
None of these throw an error. That's the common thread, and it's why they're red flags rather than bugs: the system is confidently wrong, and the people relying on it, the customer making decisions from a report, the developer whose app now has the wrong key, have no way to know.
What makes a finding read as a red flag
When I sort findings in a review, these are the questions that move something from the ordinary list to the top of the report:
- Does it contradict a claim? Something on the pricing page, in the settings, in the deck, or in the terms.
- Does it fail quietly? No error, no alert, no visible sign that anything went wrong.
- Does it touch money, permissions, or customer data? Those are the areas where "mostly works" isn't a passing grade.
- Did anyone on the team know? A known problem with a plan is a line item. An unknown one is a question about everything else.
The last question is the one founders can actually control. The same bug reads very differently depending on who raises it. "We found this, here's what we changed, and here's what's still on the list" is a founder who knows the product. Hearing about it for the first time from the investor's reviewer is the version that changes terms.
Why AI-built code produces this shape
None of these examples came from careless people, and several of these apps were built largely with AI coding tools. That's not a coincidence. An AI tool writes what you ask for, and it does its best work on the path you describe: create the record, save the setting, show the report. It's much less reliable on the paths nobody described: the restore that skips the check, the second request that loses the setting, the limit it added on its own and didn't mention.
Those undescribed paths are exactly where promises get broken, because a promise has to hold on every path, not just the one in the demo.
The useful habit is the reviewer's habit, applied early. Write down what the product promises. For each promise, find the place in the code where it's enforced, and check that every path into that data goes through it. It's a few hours of reading, and it turns the findings that would have been red flags into a list you already know about.