Andrew Ng's AI Engineering Skills Map: The 4 Skills That Matter

Andrew Ng didn't ask what's trendy in AI. He mined over 10,000 job postings to find out what's actually being hired for — and the answer has almost nothing to do with prompt engineering.

On August 14, 2026, the DeepLearning.AI and Coursera co-founder published the AI Engineering Skills Map on X: four skills, derived from job-posting analysis, structured interviews with hiring managers and recruiters, and survey data, that he argues matter more than anything else a developer can learn right now. It lands three months after Ng's three loops framework reframed how AI-native products get built — this is the step back from mechanics to ask what competencies you need to run those loops well in the first place.

Update — August 22, 2026: Ng has published Part 1 of the follow-up series, fleshing out the first of these four skills into six concrete sub-skills — read Andrew Ng's AI Engineering Skills Map, Part 1: Building and Deploying AI Applications for the deep dive on LLM foundations, grounding, agentic systems, evals, production, and ML foundations.

Update — August 29, 2026: Part 2: Software Engineering Fundamentals is now out — five skill areas (full-stack apps, data, system architecture, security and reliability, production scaling) and Ng's argument that "developers who deeply understand how software works vastly outperform those who vibe code without understanding."

Update — September 5, 2026: Andrew Ng published a detailed follow-up expanding the "Using coding agents" branch of this skills map — a planning → execution → deployment workflow, five named sub-skills, and a direct rebuttal to the idea that letting an agent run autonomously for hours is the mark of skilled use. See the new section below.

TL;DR

Why a skills map, and why now

Ng opens with the problem explainx.ai's own audience runs into constantly: "with the noisy, hype-filled, information environment around AI, what are the most valuable skills for you to learn?" Every week brings a new framework, a new agent harness, a new "essential skill" thread — and most of it is opinion, not data.

What makes this framework different is the sourcing. Ng's team didn't survey their own newsletter subscribers or extrapolate from a handful of case studies. They analyzed over 10,000 job postings, ran dozens of structured interviews with AI experts, hiring managers, and recruiters, and layered in survey data — then looked for the skills that clustered across all three sources. Ng's own framing: "You can informally think of our process as akin to running clustering on a massive dataset of jobs and expert interviews to identify the most important skills, not just today but also in the near future."

That last clause matters. This isn't a snapshot of current job titles — it's an attempt to find skills durable enough to matter as the tooling changes underneath them.

The four skills, and what each actually requires

1. Building and deploying AI applications

The defining trait of AI software, per Ng, is unpredictability: "When you prompt an LLM, you don't know what you'll get back." Traditional software behaves deterministically; AI systems don't. The skill here isn't knowing that LLMs, RAG, context engineering, and agentic workflows exist — it's knowing how to use statistical technique to measure, steer, and govern systems that don't behave predictably by default.

Ng calls out one specific capability as core to this skill: running disciplined evals and error-analysis loops. That's not a nice-to-have on top of the building blocks — it's the mechanism that turns an unpredictable system into a governable one. If you can't measure where your RAG pipeline or agent is failing, you can't fix it systematically; you're just re-prompting until it looks right on the one example in front of you.

Ng has since fleshed this skill out into six named sub-skills — LLM foundations, grounding models with data, building agentic systems, evaluation-driven development, operating in production, and machine learning foundations — in Part 1 of the follow-up series.

2. Software engineering fundamentals

This is the skill most likely to get skipped by someone excited about AI tooling, and it's the one Ng spends the most words defending. Engineering software means trading off cost, scalability, reliability, and speed against each other — and understanding those tradeoffs is what lets a developer recognize which one even applies to the problem in front of them.

Ng draws a sharp contrast here: an inexperienced developer who vibe codes a solution without knowing the tradeoffs their coding agent is making will typically get poor tradeoffs, because they don't know what context to feed the agent to steer it correctly. Software fundamentals aren't a competing skill to agentic coding — they're the language you use to direct it. A developer who knows what "eventual consistency" or "N+1 query" means can tell an agent exactly what constraint to respect; a developer who doesn't just hopes the agent guesses right.

3. Using coding agents

Ng treats this as a distinct, learnable skill in its own right — not something you pick up passively by using Cursor or Claude Code for a few weeks. It requires a working mental model of how agents actually operate: their limitations, how to work around them, and — critically — knowing how much to intervene and how much to leave the agent alone.

The specifics Ng names read like a checklist for anyone building agentic workflows today:

• Managing an agent's context window deliberately, not letting it fill with noise
• Trading off planning against execution — when to write a detailed spec first versus let the agent explore
• Giving agents verifiers or evals so they can close the loop autonomously, rather than requiring a human check at every step
• Knowing when a clear spec is worth writing — and when it isn't
• Orchestrating multiple agents working together on the same task
• Avoiding concrete failure modes, like an agent with unrestricted access wrecking a production database

Ng adds a meta-point that's easy to underweight: because agentic coding tooling changes fast, "using coding agents skillfully means not only knowing cutting-edge practices, but also having routines to keep trying new tools and evolve your workflows." The skill isn't a fixed technique — it's a habit of re-evaluating your workflow as the tools underneath it shift, the same discipline explainx.ai covers in its loop engineering guide.

Ng has since published a full deep dive on exactly this skill — see the dedicated section below for the five sub-skills, the planning → execution → deployment workflow, and his argument against "set it and forget it" long-horizon runs.

4. Shaping the build

This is the skill with the most career-defining implications, and the one least covered by technical tutorials. Ng's argument: coding agents are rapidly improving at delivering to a clear spec, so the actual engineering work is shifting upstream — toward deciding what should be in the spec. "Engineers should no longer expect to be given a pixel-perfect design and asked only to implement it."

That shift requires product sense and an understanding of business context and customer goals — skills traditionally siloed into product management, now folding into the engineer's own job. Ng frames it as opportunity, not burden: AI gives individual developers more ownership and agency than before, letting them identify problems and opportunities and execute on them directly. The practical skill underneath that opportunity is judgment about pace — knowing when to ship a rough MVP to real users for testing versus when to slow down and build more carefully. That's the same tension Ng's own three loops framework describes mechanically: an inner coding loop running on minutes, wrapped by slower human and market feedback loops that decide what the inner loop should even be building.

Ng's deep dive: the five sub-skills of using coding agents

On September 4, 2026, Ng published a dedicated follow-up on X expanding skill #3 — "using coding agents" — with the same rigor Part 1 and Part 2 gave the other branches. It's paired with an updated diagram showing "Using coding agents" as one of four top-level branches (alongside building/deploying AI applications, software engineering fundamentals, and shaping the build), each breaking further into named sub-branches.

Ng frames why this branch deserves its own deep dive: it's evolving faster than the other three top-level skills. "Proprietary agents (like Claude Code, Codex, and Cursor) and open agents (like OpenCode and Pi) progress in strides via both harness and model improvements," he writes — so keeping current requires "a continuous process of experimentation, building, and learning," not a technique you learn once.

The workflow underneath the skill: planning, execution, deployment

Before naming the five sub-skills, Ng lays out the high-level workflow they all serve — drawn from interviewing dozens of top AI engineers and observing his own team:

1. Planning — brainstorming (research, experimentation, understanding the existing codebase), then writing a spec that captures requirements, technical design, and architecture, followed by generating an execution plan. Ng recommends reviewing that plan explicitly: interrogate key assumptions, check for security gaps, and watch for overengineering.
2. Execution — building, testing, and verifying, with "the right balance between agent autonomy and human oversight." This splits into (i) having the agent build with a calibrated autonomy level and (ii) verifying its output via automated and/or human checks.
3. Deployment and monitoring — deploying, "perhaps gated with a CI/CD pipeline or additional human gates," then using agents to watch logs, surface issues, and propose and execute improvements.

Ng is explicit that this looks like the pre-agent software development lifecycle for a reason — it is the same lifecycle. What's changed is where the effort goes: "we focus much less on code and instead focus on deciding what to build, designing the architecture, writing the spec, and verifying outputs." The duration of each step varies wildly by project, steps get skipped, and — the point he returns to at the end — "the workflow is highly iterative, and skilled developers know when feedback from a later step should lead them back to an earlier one."

The five sub-skills

1. Directing the workflow. The meta-skill of navigating the three steps above: deciding how much human vs. agent effort each step gets, when to iterate back to an earlier step, and understanding the tradeoffs of speed, cost, risk, and human effort involved in each choice. This is the sub-skill that ties the other four together — it's judgment about when to apply the others, not a technique in itself.

2. Enabling agent autonomy. Choosing the right autonomy level per task — interactive back-and-forth, delegating a large chunk of work, or looping until success — plus managing context carefully across build phases, deciding when to run many agents in parallel with orchestration (the same territory explainx.ai covers in its guide to Claude Code subagents and multi-agent workflows), managing human attention across concurrent sessions, and running agents safely with permissions and gating to limit the risk of leaks, data loss, or damage.

3. Reviewing the work. Designing testing and validation matched to the task — both behavioral and functional — having agents provide screenshots as evidence, using eval sets and LLM-as-a-judge for qualitative checks, deciding how much of review to automate, using agentic code review and AI security/architecture audits, inserting human review judiciously, and verifying deployment plus operationalizing monitoring and incident management with agents.

4. Customizing the agent and its environment. Integrating agent skills, plugins, and MCP servers and pruning them when obsolete, using hooks to automate repeatable steps (code review triggers, CI/CD), maintaining standing context — Ng names AGENTS.md and CLAUDE.md specifically — with codebase info, architecture, style, and data-access patterns (see explainx.ai's guide to agent markdown files like AGENTS.md and CLAUDE.md), preserving state across sessions and parallel agents, accumulating learnings via post-run retrospectives, setting conventions so the codebase is agent-navigable, and coordinating context across a team's agents.

5. Coding agent foundations. Understanding how agents actually do codebase search and retrieval, manage context windows, how operations like adding tools or MCP servers affect that context, how agents and subagents interact, and how an agent is built by wrapping a harness around an LLM. Ng's point here is practical, not academic: this foundational knowledge "demystifies the agent," helps you recognize failure modes — overengineering, losing rigor from no explicit verification, stopping short, risky destructive actions — and helps you steer the agent and spot when it's going off-track.

Ng's rebuttal to "set it and forget it"

The closing argument is the most quotable part of the post, and it's aimed squarely at a narrative explainx.ai has covered from the other direction: social media, Ng says, "often oversimplifies coding-agent use." Letting an agent run autonomously for hours, burning millions of tokens, is sometimes useful — but "the practical utility of very long-horizon tasks — especially relative to cost — has been overhyped." His conclusion: "Most effective coding-agent use is a complex, highly iterative process, and high-skill human judgment/intervention gives much better results than 'set it and forget it.'"

That's a direct, quantified example of the tradeoff Ng is describing already exists in explainx.ai's own coverage. When an unreleased Claude research model pushed the Riemann hypothesis lower bound from 41.6% to 67.2%, it took roughly 60 subagents and 31 million output tokens across two sessions — and 650 of the ideas explored along the way failed. That's not a criticism of the run (the result was genuinely valuable, at roughly $310 in output billing alone), but it's exactly the ratio Ng is warning developers to budget for: long-horizon, high-token-count agent work pays off unevenly, and most of the spend goes into paths that don't work. Ng's argument is that this is the exception, not the default mode worth reaching for on a typical engineering task — where a human directing shorter, reviewed iterations beats letting an agent loop unsupervised for hours.

Ng closes by framing this skill as positioning engineers to steer the overall build — "with more to come in a future article."

What people are asking

Is this only relevant if my title says "AI Engineer"? No — and Ng is explicit about this distinction. He deliberately talks about "AI Engineering skills" rather than the "AI Engineer" role, drawing a direct comparison to cloud skills: every developer today needs to work with the cloud, but only a minority carry a "Cloud Engineer" title. His claim is that full-stack engineers, data engineers, DevOps engineers, and machine learning engineers will all need these four skills regardless of what's on their business card.

Where does prompt engineering fit into this? It doesn't get its own category — it's a subcomponent of skill #1 (building AI applications), and a relatively small one at that. Ng's framework puts far more weight on software engineering fundamentals and product judgment than on prompting technique, which is a useful corrective for anyone treating "learn to prompt better" as the whole of AI upskilling.

How is this different from just "learn to code with AI"? Three of the four skills — software fundamentals, agent orchestration, and shaping the build — are explicitly about judgment and steering, not about the mechanics of getting an agent to produce code. Ng's point throughout is that the code-generation part of the job is becoming commoditized fastest; the parts that remain scarce are the parts requiring human judgment about tradeoffs, priorities, and pace.

What should I actually do with this? Treat it as a self-audit, not a reading list. For each of the four skills, ask honestly which one you're weakest in — most developers coming from a traditional software background are strong on #2 and weak on #1 and #4; most developers coming from a pure prompting background are the inverse. explainx.ai's bootcamp curriculum is built around exactly this gap: pairing the building-blocks knowledge (LLMs, RAG, evals) with the software-engineering discipline and agent-orchestration practice that Ng's research says employers are actually screening for.

Is there more coming? Yes — Ng said this post was an initial synthesis and that more detail on each of the four skills was coming. That's already delivered three follow-ups: Part 1, on building and deploying AI applications (August 21), Part 2, on software engineering fundamentals (August 29), and the September 4 deep dive on using coding agents covered above, with Ng saying more is coming. explainx.ai will track and cover each expansion as it lands.

The takeaway

The most useful thing about Ng's framework isn't any single skill on the list — it's the ordering. Three of the four skills (fundamentals, agent orchestration, shaping the build) are about judgment under a system you don't fully control, not about producing more code faster. That tracks with what forward-deployed engineering roles have been rewarding all year: not raw output, but the ability to know what to build, steer an agent toward building it correctly, and recognize when the tradeoffs the agent picked were wrong. If you're deciding what to learn next in AI, Ng's data-backed answer is clear: spend less time hunting for the perfect prompt and more time on the fundamentals and judgment that make an agent's output trustworthy in the first place.

Related on explainx.ai:

• Microsoft Says Coding Is "Worth It Now More Than Ever" — X Disagreed
• Andrew Ng's AI Engineering Skills Map, Part 1: Building and Deploying AI Applications
• Andrew Ng's AI Engineering Skills Map, Part 2: Software Engineering Fundamentals
• Andrew Ng's Three Loops for Building 0-to-1 Products with AI Agents
• Graphs vs. Loops: The Agentic AI Orchestration Debate
• Claude Code Subagents and Multi-Agent Workflows
• Agent Markdown Files: AGENTS.md and CLAUDE.md Complete Guide
• Rethinking Skills and AGENTS.md for GPT-6 Astra: A Practical Guide — the same boundary-and-completion-criteria shift, applied to prompting
• Claude's 60-Subagent, 31M-Token Riemann Zeta Run — a real-world example of the long-horizon token-cost tradeoff Ng describes
• Complete AI Builder Bootcamp Guide 2026
• Top 10 AI Bootcamps: Complete Comparison Guide 2026
• Forward Deployed Engineer: The Hottest Tech Role of 2026
• Loop Engineering: Coding Agent Loops Guide
• Agentic Fatigue: The Vibe Coding Productivity Paradox
• Evaluating Prompts: How to Measure Quality
• 3 AI skills that matter most in late 2026 and 2027: Skills, loops, MCP — a narrower, non-title-specific version of this map
• Claude Academy launch — 4D AI Fluency Framework (Aug 2026) — Anthropic's free courses for non-engineer fluency

Official sources: Andrew Ng's announcement on X · The Batch — DeepLearning.AI

Details reflect Andrew Ng's X post as published August 14, 2026. Ng states more detailed breakdowns of each skill and a fuller Skills Map are forthcoming — check DeepLearning.AI's The Batch for updates.