The morning I announced what I'd been building, a comment showed up on the post. It was friendly. It opened with a compliment, agreed with me, and then walked through a few of the risk signals worth thinking about...who owns the code, what a change actually touches when it runs, whether it goes anywhere near auth or payments. Solid stuff. It was also every point I'd made in the post it was commenting on.
Then it suggested I go build a tool that scores that risk automatically and flags it before a merge.
That tool is the thing the post was announcing. The comment read my post, agreed with my post, listed my post's own points back to me, and then recommended I build the product the post existed to launch.
I'm pretty sure no person wrote it. It had the shape you learn to spot after a while...a compliment, a neat little list, a question at the end to keep me talking, and "experience" that never once said anything the article hadn't already said. So why did I reply? Two reasons. Other people were going to read that thread, and I wanted them to see me being a decent human in it. And on the slim chance I was wrong and there was someone real back there, I didn't want to be the guy who blew them off.
So I wrote a short, warm reply. To a comment that took a machine half a second to generate.
That little exchange is the whole thing I want to talk about.
The comment cost whoever posted it basically nothing. Reading it, working out whether a human was involved, and writing something back cost me real time and attention on a morning I had none to spare. The effort didn't disappear. It just moved off the person who made the thing and onto me, the one stuck dealing with it.
That same move...cheap to produce, expensive for somebody else to sort out...isn't new. We've lived through it once already. We just called it social media.
Here's the shape of it underneath both. When making something gets cheap but judging whether it's any good stays expensive, the judging doesn't get cheaper to match. It gets pushed downstream. Whoever's producing floods the zone, and whoever's downstream picks up the tab for sorting the good from the garbage. Nobody sits down and decides this...it happens on its own the moment producing stops costing the producer anything, because judging was always the expensive part and nothing came along to make it cheap.
Posting got cheap somewhere around 2008 to 2012. All of a sudden anyone could say anything to everyone, instantly, for nothing. Some of it was worth reading. A lot of it was noise nobody thought about for even a second before hitting post. And the cost of all that noise didn't land on the people posting. It landed on you, scrolling, doing the sorting with your own thumb and your own time.
Code generation got cheap 2 or 3 years. And we're seeing the same result. The volume went way up, the thought behind each piece went way down, and the cost of that didn't land on whoever generated the code. It landed on whoever reviews it, and whoever maintains it later, and whoever's debugging it at two in the morning six months from now.
The usual complaint, "there's so much worthless junk now" is just the part you feel. What's actually going on is the cost quietly sliding downstream while nobody's watching it move.
Now, before I turn into every other "AI is drowning us in slop" post, let me be fair about the part those posts skip.
A LOT of code was already kind of disposable. Boilerplate, glue, snippets copy-pasted from the last place they worked. "Ninety percent of everything is junk" is an old line, and it was true long before anyone had an LLM. The ratio of lazy to careful probably hasn't shifted as much as it feels like it has.
Two things did shift, though. One is just raw volume...there's so much more of it now. The other one is sneakier. Generated code shows up looking good. Clean formatting, sensible names, all the little signals you use to tell at a glance that someone thought about what they were doing. Except this time nobody did. And that surface polish is exactly what slips past a quick review, because the usual tells that something got slapped together aren't there anymore.
So is this just something myself and a few other are feeling? It turns out, there's actual evidence...a company called GitClear looked at 211 million changed lines of code from 2020 through 2024, the same stretch AI coding assistants went mainstream. Across those years the share of code that was just copy-pasted kept climbing, and the share that got refactored...actually cleaned up and reused...kept falling. In 2024 the two crossed for the first time. More copy-pasting than reusing. More produced, less considered, and now there's a graph of it.
Here's where code and social media stop being the same story, though, and it's the part that should bug you (I know it bugs me).
A worthless post is gone in a day. It slides off the bottom of the feed and that's the end of it. Social media's flood is exhausting, but it's an attention problem, and attention problems clean up after themselves. Tomorrow the feed is fresh.
Worthless code doesn't slide anywhere. It gets merged. Now it's in your codebase, and the next feature gets built on top of it, and the one after that. And you're the one maintaining it, long after whoever generated it has moved on. You maintain it for years.
A bad post costs you a second of your morning. A bad merge costs you a little more every month until you finally tear it out, long after everyone's forgotten it was ever a shortcut.
This is what has been on mind over the past week. The flood looks the same in both places. The difference is that one of them washes away on its own, and the other one is still sitting in your repo the day you leave.
Sources
GitClear. (2025). AI Copilot Code Quality: 2025 Data Suggests 4x Growth in Code Clones. https://www.gitclear.com/ai_assistant_code_quality_2025_research
I'm building Merge Lantern, risk intelligence for small engineering teams. It flags which open pull requests most need senior eyes before they merge, in one short daily digest. It's early, and the first 5 design partners get their first 6 months free. If your team feels this problem, join the waitlist at mergelantern.com.
Top comments (8)
Great article. The discussion around AI-generated code and social media incentives is important because the biggest risk is not AI writing code — it is the way we evaluate and share that code.
A screenshot of a generated app can look impressive, but production engineering starts after that moment:
Can the system handle failures?
Is the architecture maintainable?
Are security boundaries properly designed?
Can another engineer understand and extend it?
Are there tests and observability in place?
AI has made the first 80% of building something much faster, but the last 20% — reliability, scalability, security, and operational maturity — still requires engineering judgment.
I’ve found the most effective approach is treating AI as an engineering multiplier rather than a replacement:
Use AI for exploration and acceleration
Keep humans responsible for architecture and trade-offs
Validate generated code with real-world constraints
Focus on outcomes, not just demos
The industry is moving from “can AI generate this?” to “can we build reliable systems with AI?”
That distinction will separate prototypes from products.
Great discussion. 👏
Thanks Luis,
You pinned the exact center of it...the risk lives in how we evaluate and share the code, which is exactly what I was trying to get at.
The one thing I'd add clarity on in your 80/20 is I don't think AI shrank the hard 20%. It made the easy 80% nearly free and left the hard part exactly as hard as it always (perhaps even a little harder), so the same amount of real judgment is still there, just concentrated into a bigger share of what's left, all of it pointing at evaluation. That's why review is where everything now piles up. The cheap part got cheaper and the expensive part didn't move.
I also like the "can we build reliable systems with AI" question. It's def the thing that separates prototypes from products.
The social media layer rewards impressive screenshots, not maintainable systems. That skews expectations around AI code generation because the visible artifact is usually the generated diff, not the review cost, rollback path, test quality, or the next developer’s ability to change it safely.
The part that stuck with me wasn't the code it was the idea that AI shifts effort rather than eliminating it. Generating something has become almost free, but reviewing, validating, and maintaining it is still a very human cost. That's an easy trade-off to overlook when productivity is measured only by output.
The reason it's so easy to overlook is that the effort moving downstream is invisible to whatever's measuring. You can count what got generated...lines, PRs, tickets closed. You can't count the outage that didn't happen, or the 2am debugging session a careful review saved someone from. So a team measuring productivity by output isn't ignoring that cost on purpose...it literally can't see it. The countable half wins by default.
The launch-day comment story is painfully recognizable. What got me wasn’t just that it was probably generated — it’s that you still had to spend real attention deciding how to respond, for an audience that might read the thread. That’s the asymmetry in miniature.
The social media parallel is sharp, but I think your distinction at the end is the important one: attention problems reset; repo problems compound. A polished diff can look “reviewed” in ways a sloppy paste never did, which makes the downstream cost harder to see until maintenance starts.
Curious whether you think review tooling can ever really close that gap, or if the fix is mostly cultural — making “who owns this after merge?” as normal a question as “does it pass CI?”
I don't think it's really tooling or culture...they're doing two different jobs. Tooling can't own the code for you, and "who owns this after merge?" is exactly the question worth making as normal as "does it pass CI?". But right now that ownership question gets asked with no information about which merges actually carry risk, and that's why it isn't purely cultural. That's the gap tooling can close...not by reviewing the code for you, but by pulling the invisible downstream cost forward so it's visible at merge time instead of at 2am six months later.
And part of why "who owns this?" feels like the only lever left is that the tooling we already have measures the fakeable half. A polished diff sails through CI, linters, coverage...those were the surface checks, and AI games them by default, so "does it pass CI?" quietly stopped being a good proxy for "is this safe?". The gap doesn't close by picking tooling or culture. It closes when tooling stops rewarding what looks clean and starts surfacing what actually carries risk, so the ownership call gets made with eyes open.
Some comments may only be visible to logged-in visitors. Sign in to view all comments.