I want to tell you about a version of me I almost became, and honestly, some days still am. Six years into writing software, I've sat on both sides of code review. I've been the person who caught the off-by-one error buried in a loop nobody else looked twice at. I've been the one who flagged a race condition three people already approved. That kind of catch doesn't come from being smart. It comes from reps. From reading thousands of diffs until your eyes snag on the wrong thing before your brain even knows why. That instinct doesn't disappear all at once. It gets traded away in small installments. It starts innocently. AI generates a helper function, ten lines, does exactly what you asked. You read it once, it's clean, you approve it. Next week it's fifty lines. You skim instead of read, because it worked last time. Then it's an entire module handling error states, and you're not reading anymore, you're pattern matching against the shape of correct code, not the substance of it. It looks right. It compiles. Tests pass. You approve. Nobody decides to stop verifying. It happens gradually enough that you never notice the exact commit where skimming turned into rubber stamping. Here's the part that bothers me most. I've watched this exact arc happen to coworkers and friends who are better engineers than I am. People with the sharpest pattern recognition in the room, the ones everyone used to route their gnarliest bugs to. And they are, without exception, the ones I've watched stop looking closest. Not because they got lazy. Because their competence bought them confidence, and confidence is exactly what erodes vigilance. The junior engineer still reads every line because they don't trust themselves yet. The senior engineer stops reading because they've earned the right to trust themselves, and now that trust has quietly transferred onto something that hasn't earned it at all. That's the trap. The people most equipped to catch AI's mistakes are the ones most likely to stop checking for them. I think about this as tech debt. Not the kind you track in a ticket, the kind that lives in habits. Every approved PR you didn't actually read is a small loan against the future. It doesn't come due immediately. It comes due six months later, when the subtle bug AI introduced has been built on top of by three other people, and now nobody remembers there was ever a shortcut taken at all. Except by then it's not a shortcut. It's the foundation. I don't think the fix is refusing to use these tools. That ship has sailed and honestly, it should have. The fix is being honest about what's happening to our own habits in real time, which is uncomfortable, because it means admitting competence isn't protection. If anything, it's exposure. So here's what I want you to actually do. Pull up the last five PRs you approved that touched AI-generated code. Ask yourself, honestly, did I read those, or did I recognize the shape of something that looked fine. If you can't tell the difference anymore, that's not a compliment to how good the AI has gotten. That's the debt, and it's already on your balance sheet.