I'm a non-engineer, and over the last year I built an application with a codebase on the order of ~70,000 lines, almost entirely with AI-generated code.
What surprised me wasn’t that AI could write code — it was that as the codebase grew, design constraints slowly eroded, even when prompts and instructions were carefully written. Over time, violations accumulated, and the system eventually broke in ways that were hard to reason about.
In practice, this emerged only as the codebase grew well beyond what prompt-only workflows usually survive.
I found that prompt-level control wasn’t enough.
So instead of relying on code reviews (which I wasn’t capable of doing properly anyway), I ended up building external governance mechanisms that constrain AI-generated changes at the project level.
Concretely, this includes:
- gates that block changes when project rules are violated
- snapshot comparisons to detect structural drift
- dynamic checks (e.g., snapshot-based regression detection) that act as substitutes for manual review
This doesn’t mean “no review is needed” in general.
What I’m claiming is narrower: in this specific case, external gates reduced the need for human code review enough for a non-engineer to keep a large system coherent.
Here are the things you can actually inspect:
- a working demo (two variants; sanitized for IP reasons)
- before/after code comparisons
- a public GitHub repo showing the architecture and integration
I’m not claiming this approach is optimal or general-purpose.
There are scenarios I haven’t validated yet, and I’m sure there are failure modes I haven’t seen.
What I am interested in is feedback on:
- whether this kind of external governance could realistically reduce review burden in AI-assisted development
- where it would obviously fail
- whether others have observed similar breakdown patterns in large AI-generated codebases
If I’m missing something obvious, I’d genuinely appreciate corrections.
Hi HN,
I'm a non-engineer, and over the last year I built an application with a codebase on the order of ~70,000 lines, almost entirely with AI-generated code. What surprised me wasn’t that AI could write code — it was that as the codebase grew, design constraints slowly eroded, even when prompts and instructions were carefully written. Over time, violations accumulated, and the system eventually broke in ways that were hard to reason about.
In practice, this emerged only as the codebase grew well beyond what prompt-only workflows usually survive.
I found that prompt-level control wasn’t enough. So instead of relying on code reviews (which I wasn’t capable of doing properly anyway), I ended up building external governance mechanisms that constrain AI-generated changes at the project level.
Concretely, this includes: - gates that block changes when project rules are violated - snapshot comparisons to detect structural drift - dynamic checks (e.g., snapshot-based regression detection) that act as substitutes for manual review
This doesn’t mean “no review is needed” in general. What I’m claiming is narrower: in this specific case, external gates reduced the need for human code review enough for a non-engineer to keep a large system coherent.
Here are the things you can actually inspect: - a working demo (two variants; sanitized for IP reasons) - before/after code comparisons - a public GitHub repo showing the architecture and integration
I’m not claiming this approach is optimal or general-purpose. There are scenarios I haven’t validated yet, and I’m sure there are failure modes I haven’t seen.
What I am interested in is feedback on: - whether this kind of external governance could realistically reduce review burden in AI-assisted development - where it would obviously fail - whether others have observed similar breakdown patterns in large AI-generated codebases
If I’m missing something obvious, I’d genuinely appreciate corrections.
Thanks for reading.