AI Can Generate Code. Engineers Must Still Understand It.

Some schools are telling Sierra Leonean students that coding is dead and software engineering is obsolete. Here is why that is the most expensive lie a young technologist can be sold — and a simple test for whether the person selling it can build anything at all.

Tabempa Engineering — Insights Software Engineering · Opinion By Alpha S. Mansaray

The lie, and who pays for it

There is a claim circulating in some of Sierra Leone's technology schools, delivered to students with the confidence of settled fact: there is no point learning to code, software engineering is dead, programming languages are obsolete, because artificial intelligence can now do all of it for you.

It is worth being blunt about what this is. It is not a hot take or a provocative classroom thought-experiment. It is a falsehood, taught for money, to young people who often cannot afford to waste the fees — and who are being sent into a global labour market with a handicap they did not choose and do not yet understand. A Sierra Leonean developer competing for remote work or a contract is not competing against the student two desks over. They are competing against engineers in Lagos, Nairobi, Bangalore, and Warsaw who were taught the fundamentals properly. Tell a paying student that the core skill is obsolete, and you have not freed them from anything. You have disarmed them and pointed them at a gunfight.

This piece is going to dismantle the claim completely — not with opinion, but with the kind of evidence that is hard to wave away. And then it is going to give students a simple, fair test they can run for themselves, so they never have to take anyone's word for it again, including mine.

The category error at the centre of it

The whole lie rests on a single sleight of hand: it quietly swaps producing code for engineering software, as if they were the same thing. They never were.

Typing out lines of code was always the cheapest, most junior part of the job. The expensive part — the part that was always the actual work — is deciding what to build, designing a system that does not collapse the first time real users hit it, finding the bug that only appears in production at 2 a.m., and judging whether a given piece of code is correct, secure, and maintainable. AI has made the cheap part cheaper. It has not touched the expensive part. If anything, by flooding the world with cheap, plausible code, it has made human judgment about that code more valuable, not less.

So when a school says "the hard thing is solved, don't bother learning," they have it precisely backwards. The easy thing got automated. That raises the bar for humans; it does not remove it. An AI that writes code you cannot read is not a tool you command. It is a liability you have signed for.

The verification problem — with the numbers

Here is the argument that ends the debate, and it is not rhetorical. It is measured.

You cannot supervise output you cannot read. And AI produces output that needs supervising, constantly. In 2025 the security firm Veracode ran more than a hundred large language models across eighty real coding tasks and found that 45% of the AI-generated code introduced at least one of the OWASP Top Ten security vulnerabilities — the most common, best-documented web flaws in the industry, the ones human engineers have been trained to avoid for twenty years. For newly generated Java, the failure rate was around 72%. On cross-site scripting specifically, the generated code failed to defend itself roughly 86% of the time. Independent analysis found AI-written code carries on the order of 2.7 times the vulnerability density of human-written code, and that by mid-2025 AI-generated code was adding thousands of new security findings a month to the codebases studied.

These are not exotic edge cases. They are SQL injection, broken access control, cross-site scripting — the bread-and-butter holes through which real companies get breached and real customers' money disappears.

Now the part that should be printed on the wall of every classroom teaching the "AI does it all" doctrine. A Stanford study compared developers working with and without AI assistance, and found two things at once: the developers using AI wrote measurably less secure code — and they were more confident that their code was secure. The tool did not just produce weaker work. It produced a false sense of safety around the weaker work. And a separate 2025 study found that asking the AI to iteratively "improve" its own code made things worse, with critical vulnerabilities rising by over a third after just five rounds of refinement.

Read those findings together and the conclusion is inescapable. The person most endangered by AI-generated code is the person who cannot evaluate it — who accepts the confident output, feels safe, and ships the hole. That is exactly the person these schools are manufacturing: a graduate trained to trust output they have no ability to check. They are not producing engineers who use AI. They are producing victims of it.

AI is the new floor, not the ceiling

There is also a competitive reality the lie ignores. Everyone has the same models. The student in Freetown, the engineer in Berlin, and the firm in Bangalore are all prompting the same systems. If the AI is all you have, you have brought to the global market the one thing that is now universally free.

So what separates two developers is no longer who can produce code — the machine did that for both of them — but who can direct, verify, correct, and architect on top of it. A developer who genuinely understands systems and uses AI strictly dominates one who can only prompt. The understanding is the entire differentiator. Remove it, and you have not levelled the field; you have removed yourself from it. AI is the new floor everyone stands on. The fundamentals are the only way up from there.

The illusion dies at the first real bug

Every one of these students will, sooner or later, hit a failure the model cannot one-shot away. A subtle race condition. A production outage with a misleading error. A security incident. A piece of "working" code that quietly corrupts data for three weeks before anyone notices. That moment always comes.

And in that moment, the person with no mental model is simply stranded. They cannot read the stack trace. They cannot reason about what the system is actually doing. They paste the error into the AI, get a confident wrong answer, paste it back, and spiral — because debugging is the purest test of understanding, and you cannot prompt your way to understanding you never built. The illusion that coding was unnecessary does not survive contact with the first real bug. It just survives long enough to cost the student a job, a client, or a company.

A test you can run on the people teaching you this

Here is the part for the students, and it is the most useful thing in this article. You do not have to take my word, or your instructor's word, about whether the craft is dead. You can test it directly. The next time someone teaching you tells you coding is obsolete, ask them — politely, sincerely — to do three small things:

Read twenty lines of code aloud and explain them. Put a short, real function in front of them and ask them to walk through what it does, line by line, and — the part that matters — what would make it break. Anyone who can actually build software can do this in their sleep. It is the most basic act of the profession.

Tell you what they have personally built, shipped, and maintained. Not a certificate. Not a course completed. A real thing that ran, that real people used, that broke and had to be fixed. Ask what broke and how they found it. Builders have war stories. They light up telling them.

Debug something small, live, in front of you. Give them a tiny program with one bug and watch how they hunt it. The method reveals everything. Understanding shows; its absence shows faster.

These are not cruel tests. They are fair ones — the same ones any employer on earth will apply to you the moment you look for work. And notice the pattern they reveal: the people who have actually built and broken real systems never tell you the craft is dead. They tell you it is hard, and deep, and worth it, because they have been in it. Only someone who could never do it would need it to be dead. "Software engineering is obsolete" is not a finding about the industry. For a great many of the people saying it, it is a confession about themselves — a way to make their own inability sound like the future instead of a failure. The students pay the tuition. The instructor gets to never be exposed. Follow the incentive and you will usually find the motive.

History already settled this

None of this is new. Every powerful tool in computing's history arrived wearing the same costume — "now you don't need to understand the thing underneath" — and every time, the opposite happened.

Calculators did not kill arithmetic; they made the people who understood numbers faster and left the people who didn't unable to tell when the answer on the screen was nonsense. Compilers did not kill programming; they let people who understood logic build bigger things and made the layer beneath them more valuable to know, not less. High-level languages, frameworks, cloud platforms — each abstraction multiplied the power of those who understood what sat below it, and quietly turned everyone else into dependents who could not function when the abstraction leaked. AI is simply the newest and most convincing layer in that line. The rule has not changed: you either ride the abstraction because you understand what is under it, or it rides you because you don't. Which one you get is decided entirely by whether you did the work these schools are telling you to skip.

What this costs Sierra Leone

There is a national dimension to this that should make anyone serious about the country's future angry. We are talking about a generation of young Sierra Leoneans being trained, deliberately, into helplessness — taught to be prompt-typers in a world that will pay well for engineers and almost nothing for people who cannot check a machine's work. The rest of the world is producing builders. Some of our schools are producing button-pushers and calling it the future.

The cruelty is sharpest precisely because the opportunity is real. Software is one of the few fields where a talented Sierra Leonean with a laptop and a connection can compete globally without a visa, without relocating, without anyone's permission. Depth of skill is the entire passport. To stand in front of students holding that opportunity and tell them the skill is worthless is to pull the ladder up from below — and to charge them for the privilege.

To the student who was told the craft is dead

If you have been sitting in a classroom being told that coding is finished and you should not bother to learn it deeply, hear this clearly: you were lied to, and the lie was about the person teaching it, not about your future.

Learn to code. Learn it properly — the kind of understanding where you can read a function and know what breaks it, reason about a system, and find a bug nobody else can. Then use AI hard, as the accelerator it genuinely is, on top of real understanding, where it makes a strong engineer dramatically stronger instead of making a weak one dangerous. That combination — deep fundamentals plus fluent use of AI — is not obsolete. It is the most valuable thing you can be in this decade, and it is fully within your reach.

The people who told you the craft was dead were describing the edge of their own ability and mistaking it for the edge of the world. Walk past them. The work is still here, it is still hard, and it still belongs to whoever is willing to actually understand it. Tabempa — let's make it.

References

1. Veracode, 2025 GenAI Code Security Report — 100+ LLMs across 80 tasks in four languages; 45% of AI-generated code introduced an OWASP Top 10 vulnerability; ~72% failure rate for newly generated Java; ~86% cross-site-scripting failure rate; ~2.74× the vulnerability density of human-written code.
2. Pearce et al., Asleep at the Keyboard? Assessing the Security of GitHub Copilot's Code Contributions — ~40% of generated programs contained vulnerabilities across 1,689 programs (≈50% in C, ≈39% in Python).
3. Perry et al. (Stanford), user study on AI coding assistants — participants using AI wrote significantly less secure code while reporting greater confidence in its security ("false sense of security").
4. IEEE-ISTAS 2025, Security Degradation in Iterative AI Code Generation — a 37.6% increase in critical vulnerabilities after five iterations of AI-driven "improvement."
5. Apiiro (2025), enterprise code analysis — CVSS 7.0+ vulnerabilities ~2.5× more frequent in AI-generated code; ~10,000 new monthly security findings by June 2025 (≈10× the December 2024 figure).
6. Cloud Security Alliance / Cycode (2026) — vibe-coding security debt; ~5,600 AI-generated applications scanned revealing 2,000+ vulnerabilities and 400+ exposed secrets; ~25% of a recent Y Combinator cohort reporting 95% AI-generated codebases.

Opinion piece for the Tabempa Engineering Insights page. Security statistics are drawn from the cited 2025–2026 studies and should be re-verified against the latest reports at time of release; figures in this fast-moving area are updated frequently.