AI Can Write Code Now—Do Self-Taught Devs Still Need CS Fundamentals?

A question I keep going back and forth on

I’m a self-taught full-stack engineer—no formal CS background. The most obvious change over the past couple of years is this: AI can write a good chunk of my code. Break the task down properly, give it enough context, and it ships faster than I do.

So one question keeps rattling around in my head: if someone (or something) is writing my code for me, is there any point in going back to learn the formal CS curriculum? Data structures, operating systems, networking, databases… all of it feels pretty far removed from the day-to-day grind. Isn’t studying it just a waste of time?

I thought about it for a while, and my conclusion is clear: yes, it’s worth it—but be selective.

Here’s the reasoning in one sentence: people with weak fundamentals get led around by AI, unable to tell when it’s actually doing solid work and when it’s confidently talking nonsense.

Why stronger AI makes fundamentals more valuable, not less

AI can write code, sure. But here are a few things it doesn’t do for you:

Judging whether code is good. Any given requirement has ten ways to write it. “It runs” is just the passing grade—which version is cleaner, more maintainable, less likely to bury a landmine? That call is yours to make.

Tracking down performance bottlenecks. When production slows to a crawl, AI isn’t there on the scene; it can only guess. Actually narrowing things down and finding the part that’s dragging everything else takes your intuition for how the system runs.

Designing system boundaries. How to slice up modules, where data should live, what to decouple—these are judgment calls, not fill-in-the-blanks. AI can’t help much here.

Reading a stack trace. When a wall of stack trace gets thrown in your face, being able to spot at a glance which layer the problem is in is a hard skill that saves real time.

Every one of these leans on fundamentals. People with solid fundamentals treat AI as a fast but high-maintenance assistant they keep an eye on. People with weak fundamentals tend to treat AI’s output as gospel—when it’s right, copying it feels great; when it’s wrong, you can’t even tell, and you’ll ship the bug to production with total confidence. The more AI writes, the sharper this dividing line gets.

Ranking by return on investment

Shoring up your fundamentals doesn’t mean re-reading the entire university curriculum from scratch. For people like us who came in sideways, time is limited—you have to go after the highest-return stuff first. Here’s my priority order:

1. Data structures and algorithms—arrays, hashes, trees, graphs, plus basic complexity analysis. This is the fastest-paying chunk: reading other people’s code, getting through interviews, judging whether the approach AI hands you is sound—all of it rides directly on this. The point isn’t to hand-roll a red-black tree; it’s to glance at a piece of code and know roughly how fast it is and whether it’ll blow up.

2. Operating systems + networking—processes and threads, how memory actually works, how TCP and HTTP run under the hood. This is what gives you the low-level intuition for debugging production issues. Why is this request hanging, why does memory keep climbing, why do connections drop now and then—without this foundation, all you can do is flail.

3. Database internals—indexes, transactions, query plans. As long as you do backend work, there’s no getting around this. What’s really happening behind a slow query, why the index didn’t get used, why transactions are deadlocking each other—understanding this saves you enormous amounts of time spent shooting in the dark.

4. Compilers, distributed systems—pick these up on demand. No need to grind through them when you don’t need them; wait until you actually hit the wall (say, you have to stand up a multi-node service) and circle back to the relevant part. You’ll absorb it far better that way.

How to study: don’t grind through textbooks front to back

The biggest trap I fell into was trying to sit up straight and chew through a textbook from page one—only to give up two chapters in.

The more practical approach is this: tie it to the work in front of you, and go back to fill in the relevant chapter when you hit a problem. I mostly write Vue and do full-stack work these days, so I let real problems pull me along—pick up indexing while tuning a query, figure out the event loop while chasing down a janky page. When you study with a concrete problem in hand, the knowledge grows on you; it sticks far better than rote memorization in a vacuum.

For materials, I’d recommend these two kinds over university textbooks—both are far more approachable:

• 《Designing Data-Intensive Applications》 (DDIA)—it’s about how to design data systems, grounding abstract database and distributed-systems concepts in real engineering scenarios.
• MIT’s hands-on courses—like 6.S081 (operating systems) and 6.824 (distributed systems), both very much the build-it-yourself path. Working through one of them once beats reading the theory ten times over.

Wrapping up

So back to the question I opened with: AI can write code now—should you still learn the fundamentals?

Yes. And it’s precisely because AI can write code that you need them more than ever—the more AI writes for you, the more you need to be able to tell whether what it wrote is actually right.