AI lets developers build software differently than they did only a few years ago. The skills that matter now are not just “knowing AI.” They combine product judgment, software fundamentals, agent fluency, and disciplined methods for turning uncertain model behavior into dependable applications.
Ng’s map is aimed at AI engineering skills, not merely the job title “AI Engineer.” The implication is broad: full-stack, data, DevOps, ML, platform, and AI engineers will all increasingly need these capabilities.
Understand LLMs, context engineering, retrieval, agentic workflows, ML/deep learning, and—critically—the statistical techniques needed to measure, steer, and govern systems with unpredictable outputs.
Build across the full stack, manage data, design architectures, make systems secure and reliable, and operate them at scale. These skills expose the latency, availability, consistency, maintainability, simplicity, and cost tradeoffs that coding agents need humans to frame.
Develop a mental model of how agents work and where they fail. Manage context, decide how much to intervene versus let the agent run, balance planning against execution, provide verifiers so the agent can close loops, know when a clear spec is worth the effort, orchestrate multiple agents when useful, and protect production systems from autonomous mistakes—all without wasting excessive time or tokens.
As agents get better at implementing clear specs, engineers move upstream. Product sense, business context, customer goals, and ownership become core engineering skills. The opportunity is greater agency: identify worthwhile problems, drive projects responsibly, and know when to ship an MVP for user learning versus when risk demands slower, more careful construction.
The key difference is uncertainty. You do not know exactly what an LLM will return, or how a learned model will classify a new example. That changes the shape of engineering work.
Behavior is relatively predictable. A larger share of the work can be specified up front and checked against deterministic expectations.
Outputs are probabilistic. Development becomes more empirical: build something, inspect behavior, analyze errors, and use the evidence to choose the next change.
Ng’s second post expands the first skill area. The through-line is not “learn every AI technique.” It is: understand enough of the system to choose the right technique, measure what happens, and keep improving based on evidence.
Understand tokenization and generation well enough to know when a model is likely to work, where it may fail, and what model or feature choices are available. This includes multimodal models, context-window tradeoffs, cache hits, knowledge cutoffs, reasoning effort, sampling, tool calling, and when fine-tuning or self-hosting is justified.
Useful outputs require useful context. RAG with vector search is only one option. Engineers must decide what belongs directly in a prompt versus what should be retrieved on demand, and whether the right representation is a vector index, knowledge graph, semantic layer, or another structure over enterprise data.
That also means turning documents—text, PDFs, HTML, and images—into model-ready inputs and maintaining pipelines that keep data clean, current, and searchable.
Agentic systems span a spectrum: from fixed workflows containing LLM calls to open-ended agent loops where a model repeatedly decides what to do next. The engineer chooses what to chain, parallelize, implement as code, or delegate to an LLM—and designs the fallbacks.
The agent loop introduces choices about tools (including MCP, CLI tools, and sandboxes), memory, long-session context management, multi-agent orchestration, and production safety. Guardrails, adversarial inputs, governance, and risks such as data exfiltration become engineering concerns, not add-ons. Rapidly emerging application patterns—voice agents, computer-use agents, and generative UI—also reward engineers who keep up with the frontier where it matters to their use case.
Ng identifies disciplined evaluation and error analysis as a defining skill of strong AI builders. Instead of making changes at random, inspect traces and outputs, perform exploratory analysis, decide what actually matters to measure, and use the results to direct the next development step.
Good evals may be deterministic code, an LLM-as-a-judge, human review, or a mix. The evals themselves also need evaluation and improvement. The right approach varies by project and by stage.
AI production systems need observability for performance, failures, drift, security events, cost, and latency. Regression testing and CI/CD include statistical evaluations, and test rigor should rise with the consequences of a mistake.
At scale, cost and latency become architectural constraints. Model selection, distillation, fine-tuning, caching, and simplifying agentic workflows are all possible levers.
LLMs sit on top of machine learning ideas, and many useful applications still need conventional ML directly. Engineers should understand common ML and deep-learning models; the tradeoffs among accuracy, training speed, and inference speed; data engineering for training and evaluation; and core concepts such as bias/variance and error analysis.
Those concepts remain powerful because they provide a vocabulary for reasoning about systems whose outputs are uncertain.
A strong engineer repeatedly closes the gap between observed behavior and desired behavior. Intermediate results change what the team should do next.
Why this matters: with probabilistic components, the best next step is often unknowable before you inspect the current system. The skill is not predicting the whole path up front; it is choosing the next experiment well.
Ng’s third post argues that agentic coding reduces the value of memorizing syntax, not the value of understanding software. Without that understanding, a developer may never recognize the tradeoffs an agent is making—or know what context the agent needs to make a better choice.
Understand how interfaces, rendering, APIs, authentication, sessions, asynchronous work, persistence, testing, security, and accessibility fit together. An agent can help outside your specialty, but you still need a model of the whole stack to direct it.
Start from access patterns and lifecycle needs. Choose relational, document, key-value, graph, or other storage deliberately; reason about transactions, concurrency, freshness, privacy, governance, and migrations. Poor data architecture also limits what an AI system can know.
Use application context—users, latency, cost, state, and change rate—to choose boundaries, decomposition, platform, stack, and architectural granularity. Run experiments where needed, and expect the right design to change from prototype to production to scale.
Design a testing strategy, anticipate failures, degrade gracefully, and contain blast radius. Shift security earlier: inspect code, dependencies, and cloud configuration with AI tools, while using security knowledge to interpret findings and choose controls.
Understand deployment environments, release strategy, CI/CD, infrastructure, observability, alerts, and incident response. Scale from measured load using servers, load balancing, indexing, replication, sharding, or architectural change—and manage reviews, dependencies, and technical debt over time.
A coding agent can optimize only for the constraints it can see. The engineer must surface the qualities that matter and decide how they change with the project’s stage.
Coding agents can accelerate implementation, but they do not eliminate engineering tradeoffs. They raise the value of knowing what context to provide, what constraints to impose, and how to verify the result.
If agents increasingly deliver to clear specifications, the scarce skill moves toward deciding what belongs in those specifications. Engineers need more product sense, business context, customer understanding, and ownership of outcomes.
The initial map names four broad skills. Post #2 expands Building and deploying AI applications; Post #3 expands Software engineering fundamentals. Together they show why model knowledge and software judgment reinforce each other when agents do more implementation work.
These skills are becoming part of mainstream software work, just as cloud knowledge became expected across many engineering roles.
They can implement quickly, but people still have to expose the relevant constraints, choose tradeoffs, and verify the resulting system.
Agentic coding, model capabilities, tooling, and best practices are changing quickly. Strong engineers need routines for trying new tools and updating their workflows.