First time I let a coding agent build a feature, it wrote 400 lines in like 20 seconds.
I felt like a genius. Then I actually read the code.
Hardcoded API keys. Zero error handling. A database query that would fall over if 50 people used it at once.
The worst part? I didn't even know it was wrong. I couldn't see the problems because I didn't know what to look for.
That's the thing about AI coding nobody warns you about. The tools are amazing. But they'll make bad calls all day long if you don't know enough to stop them.
Andrew Ng said it better than I can:
"Even when you use a coding agent to write all your code, understanding software fundamentals is important for steering your agent to make the tradeoffs you want — or to even know what tradeoffs exist to be made."
So yeah. That's the whole game now. Let me break down what actually matters.
AI-Generated Code vs Human-Written Code
AI-Generated Code vs Human-Written Code
The Uncomfortable Truth
Writing code isn't the job anymore.
I know that sounds dramatic. But hear me out.
Matt Pocock has been an engineer for almost 10 years. He puts it like this: you now have "a fleet of middling to good engineers you can deploy at any time." Cool, right?
Except they have one problem.
They don't remember anything.
No memory of yesterday. No memory of the architecture you agreed on last week. Every session is a fresh start.
So your job changes. You're not writing code anymore. You're:
Telling the agent what you want (clearly, or it'll guess wrong)
Checking what came back (because it might be broken)
Fixing things when they go sideways
Andrew Ng says memorizing syntax is basically dead. But devs who really understand how software works? They crush it. Devs who just vibe code without understanding? Not so much.
Jensen Huang from Nvidia said something I keep thinking about:
"The barrier to producing code has fallen. The barrier to producing correct, secure, maintainable code has not moved."
That's it. That's the whole thing.
If want want to know more, read me 10 AI Skills to Stay Relevant in the Job Market
The Stuff You Can't Skip
You can't skip the fundamentals. I tried. It doesn't work.
Andrew Ng's team looked at 10,000+ job postings and talked to a bunch of experts. They found five areas every dev still needs.
1. Full-Stack Basics
AI coding made everyone a full-stack dev whether they wanted to be or not.
Frontend person? Now you're touching backend. Backend person? Now you're dealing with UI.
You don't need to be an expert at everything. But you need to know enough to catch when something's off.
Stuff to know:
How UI components and caching work
API design and auth
State management
Async processing
Testing
Accessibility
You get the idea.
2. Data (The One Everyone Sleeps On)
Data is the most underrated skill on this list. Hands down.
Why? Because once you pick a data model, changing it later sucks. Even with AI helping.
If you actually understand data, you can:
Figure out what to store and how long to keep it
Pick the right storage type (SQL, document, key-value, graph)
Handle transactions and concurrency without breaking stuff
Here's the part that matters for AI: your AI pulls context from your data. If your data setup is a mess, the AI doesn't know what it doesn't know.
It'll confidently give you answers based on garbage. And you won't catch it.
3. System Design
Good system design starts with questions:
How many users?
Does latency matter?
Does cost matter?
Then you decide:
What platform
Where frontend ends and backend starts
Monolith or microservices
What stack to use
Here's the annoying part: the right architecture keeps changing. What works for a prototype breaks in production. What works for 1,000 users breaks at 100,000.
4. Security and Reliability
This is where AI code scares me the most.
You need to know:
How to test stuff (unit vs integration, how much coverage)
How to handle failures (rate limits, services going down)
How to limit the damage when things break
Basic security — because AI moves fast and leaves holes
Security work happens earlier now. That "shift left" thing. Most devs are part security engineers whether they like it or not.
5. Shipping and Keeping It Alive
Building something that works on your laptop? Easy.
Keeping it running for real users? Different sport.
You need to understand:
Deployment and release strategies
CI/CD
Monitoring and alerts
Scaling servers, load balancing, data stuff
Nobody tweets about this stuff. But it's what keeps your product from dying at 2am.
Know more: Gates Calls for Global AI Rules & Human Jobs
Working With Agents (The New Skill)
Fundamentals are the base. But you also need to know how to work with these tools.
Treat Them Like Juniors With Amnesia
Matt Pocock's whole thing: treat AI like humans. Weird humans who forget everything. But humans.
That means you need strict processes. You can't just say "build me a search feature" and hope for the best.
Here's a flow that works:
Step 1: Grill yourself first.
Matt made a skill called /grill-me. It asks you questions before any code gets written.
Stuff like:
What happens when there are no results?
What if the API is down?
How should sorting work?
One session asked him 16 questions. Complex features? He's had 50.
The idea comes from a book called The Design of Design by Frederick Brooks. You gotta walk down every branch of your design tree before you commit to code.
Step 2: Turn it into a spec.
Matt's /to-spec skill takes the conversation and writes it up. User stories, plain language. That's your contract with the agent.
Step 3: Break it into tickets.
Spec is where you're going. Tickets are how you get there.
Each ticket should be a thin "vertical slice" — cutting through all the layers. Not one chunk of just frontend or just backend.
Step 4: Do TDD.
This is the big one. Matt calls TDD "the most consistent way to improve agent outputs."
Write a test first. Agent writes code to pass it. Then you clean up.
Red. Green. Refactor. Repeat.
That loop keeps the agent honest. And you can actually tell if it worked.
Step 5: Fix your codebase.
Agents work better in clean code. If your codebase is a dumpster fire, the AI makes dumpster fire code.
Matt says do an architecture review once a week or after a big push.
The Skills People Actually Use
Melvynx tested a ton of community skills. Here are the 5 he never removes:
Skill | What It Does | Why Bother |
|---|---|---|
Grill Me | Interviews you about your plan | Stops half-baked features |
APEX | Plans, codes, tests, screenshots | Catches bugs before you see them |
Impeccable | Fixes ugly AI designs | Makes UIs look like a human made them |
Make Interface Feel Better | Polishes tiny details | Turns "fine" into "nice" |
Thermo-Nuclear Review | Brutal code audit | Stops tech debt piling up |
APEX is wild. It doesn't just write code. It runs the app, screenshots it, and shows you. So you can look and go "that's wrong" before ever touching it.
Context Engineering (The Skill Nobody Talks About)
If there's one new skill that ties everything together, it's context engineering.
Here's the problem. AI models can only hold so much in their "head" at once. You can't dump your whole codebase in and expect good answers.
So you have to engineer the context. Pick what to include. Structure it well.
This is different from prompt engineering. That was about asking questions cleverly. This is about:
What to include (and what to leave out)
When to load it
How to structure it
Where to pull it from
Andrew Ng puts context engineering right up there with RAG and agentic workflows.
The Indeed engineering blog calls work decomposition "one of the core skills of context engineering." Can you break a big task into pieces that fit in one context window? Congrats, that's a real job skill now.
How I'd Learn This Today
If I was starting from scratch, here's what I'd do:
Month 1-2: Nail the Fundamentals
Don't skip this. Pick one area. Data. Or system design. Go deep.
Try this: Build a small full-stack app without an agent. Then build it again with one. Compare. Notice where the agent did stuff you wouldn't have.
Month 3-4: Learn the Agent Workflow
Pick one tool. Claude Code. Cursor. Copilot. Doesn't matter.
Learn it properly. Write your own skills. Spec before code. Use TDD.
Matt's skills are a good start. Install them, use them, then tweak them to fit you.
Month 5-6: Get Into AI-Specific Stuff
RAG. Evals. Context engineering. This is where you learn to build AI apps that actually work instead of making stuff up.
This is also the stuff that gets you hired.
What Actually Matters
If you remember nothing else, remember this:
Skills for AI are like 70% software fundamentals, 30% AI-specific stuff.
The fundamentals:
Skill | Why It Matters | How to Get It |
|---|---|---|
Full-stack | Can't steer what you don't get | Build small apps start to finish |
Data | Bad data = broken everything | Study DB design |
System design | Bad calls pile up | Practice designing stuff |
Security | AI code has holes | Learn the basics |
Production | Shipping isn't the end | Deploy and keep something alive |
The AI-specific stuff:
Skill | Why It Matters | How to Get It |
|---|---|---|
Working with agents | They're your new coworkers | Use them daily, learn their limits |
Context engineering | Garbage in, garbage out | Practice structuring info |
TDD with AI | Tests keep agents honest | Write tests first |
Spec writing | Clear ask = better result | Practice user stories |
Code review | AI code needs different eyes | Read actively, ask "why" |
The Part Nobody Mentions: Judgment
All of this comes down to one thing.
Judgment.
A tool doesn't give you judgment. No amount of prompting fixes that.
When you actually understand software, you can look at AI code and just know it's wrong. You spot the missing error handling. You see the security hole. You feel when a design choice is gonna hurt in six months.
That's not something you download. You build it. Slowly. By shipping stuff and breaking stuff and fixing stuff.
The devs winning right now aren't the ones writing the most code. They're the ones who understand the most. And they use that to point their agents at good outcomes.
That's the actual skill. And yeah, it means learning the boring stuff. Data modeling. System design. Security. The stuff nobody puts in their bio.
Tools get better. Judgment is on you.
Conclusion
Skills for AI aren't really about AI.
They're about understanding how software works. Deep enough that you can aim a powerful tool at good outcomes. Deep enough that you know what tradeoffs exist instead of letting an agent pick blindly.
Andrew Ng nailed it:
"Understanding software fundamentals... leads to much better outcomes than those for an inexperienced developer who vibe codes a solution without knowing the tradeoffs their coding agent is making."
The devs winning aren't writing the most code. They're understanding the most. They read AI code and spot the missing try/catch. They feel when a design choice will bite them later. They know when to trust the agent and when to jump in.
That's the real skill. And you build it by doing the boring stuff — data modeling, system design, security basics — the stuff nobody puts in their bio.
Tools get better every year. Judgment is on you.
