The AI Engineering Skills Map According to Andrew Ng

Andrew Ng’s AI Engineering Skills Map makes a clear claim about software development in 2026: using coding agents is no longer an optional productivity trick. It is a core engineering capability that belongs beside application development, deployment, product judgment, and traditional software skills.

DeepLearning.AI published the broader AI Engineering Skills Map on August 14, 2026. On September 4, Ng followed it with a more detailed map focused on coding agents, covering how engineers should direct, supervise, review, and customize them.

The useful part is not a list of fashionable tools. Ng describes a repeatable development process in which people define the objective, delegate bounded work, inspect the results, and give the agent an environment that supports reliable execution.

The Skills Map Puts Coding Agents Beside Core Engineering

The top-level map divides modern AI engineering into four related areas:

• Building and deploying AI applications
• Software engineering fundamentals
• Using coding agents
• Shaping the build

That arrangement is significant. Coding agents are not presented as a replacement for engineering knowledge or as an isolated prompt-writing specialty. They operate within a larger process that still requires someone to identify the right problem, design the system, manage implementation, and evaluate whether the result works.

Ng also warns against treating the map as a fixed curriculum. The recommended learning mechanism is project work: build something, identify the gaps in your knowledge, study the relevant concepts, and apply them in the next iteration.

The map therefore works best as a diagnostic tool. An engineer can use it to ask where a development workflow is weak. The problem might be poor agent direction, but it could just as easily be inadequate testing, unclear requirements, bad API boundaries, or an inability to review generated code.

Five Skills Turn Agent Use Into an Engineering Discipline

Ng’s detailed coding-agent map organizes the work into five skill groups. Together, they describe something closer to supervised delegation than automated code completion.

This is a more demanding definition of agent skill than knowing how to ask a model for a function. The engineer remains responsible for the control points around generation.

The pattern resembles a feedback system. The person specifies the desired behavior and constraints. The agent investigates and proposes an approach. The person checks that approach before approving execution. Tests and code review then provide evidence about whether the implementation matches the intended result.

Better models can improve individual steps, but they do not remove the need for that loop. A capable agent given a vague objective can still produce a technically plausible implementation that solves the wrong problem.

The Recommended Workflow Starts Before Code Generation

Ng’s example begins with design rather than prompting. The human first decides what should be built, including the desired behavior, system constraints, and definition of success.

The agentic development loop then looks like this:

Planning matters because it exposes misunderstandings before they spread across a large code change. If an agent proposes modifying the wrong service, introducing an unnecessary abstraction, or ignoring an existing API, correcting the plan is cheaper than untangling the completed implementation.

Incremental execution also preserves review quality. A huge generated diff may appear productive, but it can exceed the reviewer’s ability to understand what changed. Smaller batches make it easier to connect each modification to the approved plan, test its behavior, and reverse it when necessary.

Autonomy Depends on Context, Permissions, and Feedback

Ng distinguishes managing an agent from simply starting one. Effective supervision can include planning modes, checkpoints, real-time steering, context compression, fresh sessions, and several agents working in parallel.

Each technique addresses a different constraint. A checkpoint limits how far an agent can travel in the wrong direction. Starting a new session can remove stale information. Context compression preserves important decisions while discarding an expanding transcript. Parallel sessions increase throughput, but they also require careful task boundaries so that agents do not make conflicting changes.

Autonomy should therefore expand only when the surrounding controls can support it. An agent that can edit files, run commands, access credentials, or interact with external services needs narrower permissions than one that merely explains a code sample.

Customization provides those controls and gives the agent better project knowledge. Ng’s map mentions persistent instructions, permissioning, sandboxing, subagents, skills, hooks, Model Context Protocol integrations, and reusable command-line tools or APIs.

The open AGENTS.md format gives repositories a predictable place to record build commands, testing procedures, code conventions, and security considerations for coding agents. The Model Context Protocol provides a standardized way to connect AI applications with external context and tools. These mechanisms can reduce repeated prompting, but they still need maintenance as a project changes.

The goal is not to give the agent every available capability. It is to supply the smallest useful set of instructions, tools, and permissions for the assigned task.

Software Fundamentals Become More Valuable, Not Less

The skill map includes software engineering fundamentals twice: once as a top-level area and again inside the coding-agent branch. That repetition reflects the central limitation of generated code. Producing an implementation is not the same as determining whether it belongs in a maintainable system.

Version control creates an auditable history and a way to reverse failed changes. Code review checks assumptions that tests may not capture. Good task scoping gives the agent a boundary it can reason about. API design prevents a local feature from creating unnecessary coupling elsewhere. Refactoring judgment helps an engineer decide whether the agent is repairing a problem or covering it with another layer of code.

Testing is especially important because it converts part of the specification into an executable check. Tests do not prove that a system is correct, but they give both the agent and the reviewer faster feedback about expected behavior, regressions, and edge cases.

Coding agents shift some engineering effort away from manually producing every line. They increase the value of being able to specify behavior, inspect architecture, find hidden assumptions, and recognize code that is convincing but wrong.

How to Turn the Skill Map Into a Development Plan

Ng does not present the map as a sequential course, but engineers can still use it to structure practice. The safest progression starts with bounded tasks and increases autonomy only after the review process works.

1. Choose a small change in an existing repository. A focused bug fix or minor feature reveals whether the agent can navigate real project conventions without creating an unreviewable diff.

2. Require analysis and a plan before edits. Ask the agent to identify relevant files, dependencies, assumptions, and proposed tests. Review the plan as carefully as the eventual code.

3. Approve work in small stages. Give the agent a checkpoint after each meaningful part rather than authorizing an entire project in one prompt.

4. Run deterministic checks. Use tests, type checking, linting, builds, and other project-specific validation. Then perform human review for architectural and product concerns those checks cannot measure.

5. Record recurring instructions. If every session requires the same setup commands, style rules, or test procedures, move them into repository documentation or agent configuration.

6. Expand autonomy gradually. Introduce parallel sessions, subagents, external tools, and longer tasks only when failures can be detected and contained.

Teams should measure time to a verified, accepted change rather than the amount of code an agent generates. Rework, review defects, test failures, and abandoned implementations reveal more about the quality of an agentic workflow than raw output volume.

Final Thoughts

Andrew Ng’s AI Engineering Skills Map is valuable because it removes coding agents from the novelty category. The detailed branch treats them as participants in a controlled development system built around clear intent, bounded autonomy, feedback, and verification.

The predictable failures are rarely limited to weak code generation. They emerge when the task is vague, the context is stale, the permissions are excessive, the change is too large to review, or nobody verifies that the result solves the intended problem. Coding agents can accelerate engineering work, but the quality of that acceleration depends on the engineering system around them.