Welcome to AIEdTalks’ Newsletter!

In today's edition:

Let’s dive in.

After reading, please rate today’s edition.

Jira Product Discovery gives teams one place to capture customer feedback, prioritize ideas with consistent frameworks, and build living roadmaps everyone can align on. And when it’s time to build, those decisions connect directly to delivery in Jira, so everyone can see how the roadmap turns into real work.

Try Jira Product Discovery

What changed, what didn't, and the order I'd learn it in.

Andrew Ng's team just published an AI Engineering Skills Map. It's built from more than 10,000 job postings, dozens of interviews with experts and hiring managers, and survey data, and it's split across a five-part series in The Batch.

I read all five parts. Most of it confirmed what I see every day building multi-agent systems. But one list made me stop: fundamentals.

I've been building production systems for over 18 years. In that time, “fundamentals” has meant roughly the same thing: data structures, system design, tradeoffs, and knowing your stack well. The tools changed constantly. The list didn't.

This is the first time I've seen it change.

So this issue has two parts. First, what actually changed and what didn't. Second, if I were starting today, the order I'd learn it in.

Latency, availability, consistency, cost. Every system I've shipped came down to choosing between these, and that hasn't changed.

What has changed is who makes the choice. Ng puts it bluntly: engineers who vibe code without fundamentals let the agent make bad tradeoffs, because they don't know those tradeoffs exist.

The agent will always make a choice. The question is whether you noticed it made one.

Code is cheap to rewrite now. Data isn't. A schema decision made in week one can follow you for years.

Ng adds an AI-specific twist I agree with completely: if your data architecture is poor, your AI doesn't know what it doesn't know. It won't throw an error. It will just be confidently incomplete.

That's the part that worries me. Bad data used to break things loudly. Now it fails quietly, inside answers that look right.

1. Syntax stopped being the skill.

Memorizing APIs and language quirks is becoming obsolete. Knowing why one design beats another is not. This is good news for experienced engineers, because the part we spent years building up is exactly the part that still matters.

2. Security moved left, onto your plate.

When an agent can read files, call APIs, and touch production data, every developer becomes partly a security engineer. “The security team will review it” doesn't scale to code generated in minutes.

3. Two entirely new fundamentals appeared.

Evals, meaning measuring whether your AI system actually works, and steering agents, meaning directing, reviewing, and knowing when to intervene. Neither was on any fundamentals list when I started. Both are now non-negotiable.

So if the list changed, the obvious next question is: what order do you learn it in?

This isn't Ng's plan. It's mine, built from his map and from what I've watched break in production.

Build one small AI app. Keep it deliberately simple, such as a RAG bot over your own documents.

Then spend most of the month not adding features. Spend it on error analysis instead: collect failures, group them, and find patterns. Try all three kinds of eval:

Ng calls a disciplined eval and error-analysis loop the single most important trait of people who are great at building AI systems. I'd go further: evals tell you whether everything else you learn is working. Without them, every change is a guess.

Go back to the app you built. Now:

You're not learning fundamentals from scratch. You're learning to see them in AI systems, where they're easier to miss.

Now bring in coding agents properly:

This is the fastest-changing skill on the map. Don't treat day 90 as the finish line. Treat it as the start of a habit.

The final pillar in Ng's series is the one senior engineers already practice but rarely name: deciding what to build. When agents can deliver to a spec, the valuable skill is writing the spec. Stop waiting for one. Start proposing one.

Most people start with agents because that's the exciting part. I'd put them last.

Evals come first because they make everything after them measurable. Fundamentals come second because they let you judge what the agent produces. Agent skills come third because they change fastest, and you'll pick them up quicker once you can measure and judge.

Hit reply and tell me: which of the three would you start with, and why? I read every reply, and the most interesting answers may shape a future issue.

If you prefer watching to reading, subscribe to the AIEdTalks YouTube channel. https://www.youtube.com/@AIEdTalks

AI is easy to demo. Hard to ship.

The full series in The Batch, DeepLearning.AI:

The 90-day order is my own recommendation, built on Ng's map. It is not part of his series.

I'm a research engineer with 18+ years of building production systems, 35+ patents, and 17+ publications. I work on infrastructure for multi-agent systems. AIEdTalks is my field notes: real problems, what I tried, and what I learned.

Views are my own.

💬 Hit reply. I read every reply.

▶️ Watch it instead. This week's breakdown is on YouTube. Subscribe to the channel for more.

📨 Know an engineer who'd find this useful? Share your referral link and earn rewards.

💡 Topic ideas or sponsorships: Reply to this email.

Until next time,

AIEdTalks team.

P.S. AI is easy to demo. Hard to ship. That's what this newsletter is about.