The Gatekeeper Generation

A developer at a fintech client lost three days to a reconciliation job that was silently dropping records under load. He had shipped eleven features in four months. Real output, not demo output. But this bug lived below the framework, somewhere between the ORM and the connection pool, and he could not see down there. He pasted stack traces into the assistant. The assistant proposed six fixes. Five made things worse. On day three a colleague who has been writing backend systems since 2004 read the logs top to bottom and found it in forty minutes. Not because he is smarter. Because he got burned by this exact class of bug in 2011 and the scar never fully healed.

That afternoon has been stuck in my head since.

Will developers who started their careers with AI ever build deep understanding of the systems they ship?

And if most never do, what happens to the people who have it?

Understanding was never taught. It was inflicted.

Nobody I respect learned systems from a book. The machine forced it on you. The migration that locked a table for forty minutes taught you indexes. The 2am outage taught you TCP timeouts. The memory leak you chased for a week taught you more about garbage collection than any course could. The pain was the curriculum. There was no opt-out.

Charity Majors calls software an apprenticeship industry and she is right. You cannot read your way to engineering judgment. You build it by doing the work badly next to people who do it well.

Here is what changed. AI removed the pain. Not the bugs. The pain. The productive struggle that used to be mandatory is now optional. Error appears, you paste it. Fix appears, you apply it. The loop closes in ninety seconds and nothing sticks.

Depth used to be inflicted on everyone. Now it is an elective. Electives have terrible enrollment.

The research already answered the question

I wanted this to stay an open question. The data closed it.

Anthropic published a randomized controlled trial in January. 52 engineers learning an unfamiliar Python library. The group working with AI assistance scored 17% lower on a comprehension quiz than the group coding by hand. Almost two letter grades. Debugging skills dropped hardest. And the AI group finished about two minutes faster, a difference that was not even statistically significant. They traded understanding for nothing.

One detail in that study matters more than the headline. Participants who fully delegated to the AI finished fastest and scored 39%. Participants who used the AI to ask conceptual questions scored 65% and above. Same tool. Opposite outcomes. How you use it decides whether you learn.

MIT wired 54 people to EEG caps and had them write essays over four months. The LLM group showed the weakest brain connectivity of any group and could not quote from their own essays minutes after finishing them. The researchers named it cognitive debt. Accurate name. It compounds like the financial kind.

Microsoft and Carnegie Mellon surveyed 319 knowledge workers and found the mechanism: the more people trust the AI, the less critically they examine its output. Confidence in the tool replaces confidence in yourself. So the better the models get, the less the average user verifies. Exactly when verification matters most.

Namanyay Goel wrote a post last year that traveled the whole industry because every engineering manager recognized it. Juniors with assistants running around the clock, shipping faster than ever, unable to explain what they shipped. I made a version of the same argument when I wrote that AI made learning feel pointless. The research above just put numbers on it.

These are not studies about lazy people. They are studies about incentives. The tool rewards delegation. Delegation blocks learning. That is the trap, and it is structural.

But we never understood the layer below either

I can hear the counterargument because I have made it myself. Nobody writes assembly. Nobody reads compiler output. Every generation stands on abstractions the previous generation swore you had to master. I never punched a card. I turned out fine.

Correct. And wrong.

Compilers are deterministic. GCC does not hallucinate. A compiler from 2003 produced the same output for the same input, every single run, and when it did not, that was a compiler bug and it made the news. The abstraction contract held, so ignorance below the line was safe. You could stand on the floor without inspecting it every morning.

LLMs break that contract. Same prompt, different code. Plausible, confident, and wrong in ways statistically shaped to look right. An abstraction you must verify is not an abstraction. It is a coworker. A fast, tireless, overconfident coworker.

You cannot verify what you do not understand.

That is the specific trap for AI-native developers. They need verification skill more than any generation in the history of this profession. They get the least practice building it. I wrote before that writing code got easier and being an engineer got harder. This is the same tax, applied to people who never got to build the muscle that pays it.

The gatekeepers are already forming

Look at who actually ships AI code to production. Fastly surveyed 791 developers last summer. 32% of seniors with ten or more years of experience said over half their shipped code is AI generated. For juniors it was 13%. Seniors ship two and a half times more AI code, and the reason is blunt: they can look at output and know when it looks right but is not. The people with the deepest manual experience extract the most value from the tool that was supposed to make their experience obsolete.

Anthropic’s earlier research found AI speeds you up by around 80% on tasks where you already hold the skill. Their new study shows the same assistance blocks you from acquiring skills you do not hold. Read those together. AI compounds existing understanding and taxes missing understanding. That is a wealth transfer. From the shallow to the deep.

The gate is forming, and here is the part people get wrong: the gate is not age. The gate is whether you ever opened the hood. It correlates with age only because my generation had no choice. There are AI-native developers right now choosing the hard path, asking the model why instead of just give me, reading code they did not write. They will walk through the gate too. There will not be many of them.

I made a prediction earlier this year and I am sharpening it now: the highest-leverage engineering role of the next decade is the Verification Engineer (Turkovic prediction, 2026). The person who signs off. The person regulators, insurers, and boards will eventually require by name. Every industry that automated grew a role like this. Aviation kept type-rated captains after autopilot. Construction kept the structural engineer who stamps the drawings. Software is about to grow its stamping class.

Gatekeeping sounds ugly. It is just what verification looks like when verification is scarce.

We already ran this experiment. It is called COBOL.

You do not need to speculate about what happens when the people who understand a system retire. Around 220 billion lines of COBOL still run in production. An estimated 3 trillion dollars in transactions pass through it daily. 95% of ATM transactions touch it. When New Jersey’s unemployment system buckled under pandemic load in 2020, the governor publicly asked for volunteer COBOL programmers. Retired ones. There is a company literally named COBOL Cowboys that contracts retirees back into banks, some of them earning more now than they did in their full careers.

Here is the detail everyone misses about COBOL. The problem was never syntax. A competent developer learns COBOL grammar in two weeks. The problem is that nobody left remembers why the batch job must run in that exact order on the last business day of the month. What died was not the language. It was the context. The decisions. The scar tissue.

Now scale it. COBOL is one language in one sector and it produced a decades-long crisis. I documented every wave of technology that was supposed to eliminate programmers, and each wave left behind systems that outlived their builders. The AI-era version is every language in every sector, plus a generation trained by its own tools not to look underneath.

When the old ones retire

Do the math with me. The last cohort forged the old way entered the industry around 2022. They retire in the 2060s. But the engineers with twenty years of scar tissue, the ones you actually call at 2am, are mostly 45 to 60 right now. That group is gone by the early 2040s.

Three futures. I think we get all three at once.

AI closes the gap itself. The models become the deep understander, reading systems better than any human. Partially true already. But then a new question arrives.

Who verifies the verifier?

The trust problem does not disappear. It moves up one level and gets more expensive.

Understanding becomes a priesthood. Systems archaeologists billed like forensic accountants, flown in when the ledger stops balancing and the AI keeps confidently proposing fixes that make it worse. COBOL Cowboys for everything. I would put real money on this one. It is already the fractional CTO business model, just earlier on the curve.

Depth becomes a classical discipline. Taught like Latin. Studied by few, dismissed as impractical, and desperately needed at the worst possible moments.

The part that actually worries me is none of those. It is this. The models trained on everything we wrote down. Every public repo, every Stack Overflow answer, every postmortem that got published. But the reason the retry logic has jitter, the outage that explains one weird timeout value, the migration that failed in 2014 and shaped every schema decision since. Nobody wrote that down. It lived in people.

The models have our syntax. They do not have our scars.

The short version

Developers who start with AI can still build deep understanding. The research shows exactly how: use the model to ask why, not just to produce. Almost none will, because nothing forces them to, and pain was always the teacher. The few who choose depth, plus the pre-AI generation, become the verification layer for all software. That layer ages. Then it retires. Somewhere in the 2040s we find out what a civilization pays when nobody remembers why the systems work.

We already know the small-scale answer. It costs whatever the retired COBOL programmer decides to charge.

Final Words.

I might be wrong about the timeline. I might even be wrong about the gate. If you believe AI-native developers will build the same depth through different means, make that argument to me, because nobody has made it convincingly yet. And if you have watched this play out on your own team, in either direction, I want to hear what you saw.

You can follow my longer thinking on LinkedIn, argue with me on X, or catch the shorter takes on Threads.

If you want to talk through any of this in the context of your own product or engineering organization, reach out through my contact page.

And if you are hiring or need a fractional CTO who can tell you which side of the verification gap your team sits on, book a call: cal.eu/ivan-turkovic/30min.

Who on your team can still read a stack trace without pasting it into a chat window?