Software Engineering Still Matters. The Reason Changed.

Andrew Ng published the second article in his AI Engineering Skills Map series on August 28. The first, a week earlier, covered building and deploying AI applications, and I wrote a note on that one. This one is about software engineering fundamentals, and its central argument is a reframe: the discipline still matters, but the reason has changed.

The shift, as Ng puts it, is that a coding agent writing all your code does not remove the need to understand software. It changes what the understanding is for. You use it to steer the agent toward the tradeoffs you want, and to know which tradeoffs exist to be made in the first place. He is specific about the failure mode:

"A novice who vibe codes without understanding software fundamentals can create simple applications, but this often leads to the coding agent making bad tradeoffs in latency, availability, consistency, reliability, maintainability, simplicity, and/or cost."

The developer never corrected the agent, Ng writes, because the developer did not know those choices existed.

The five skills

Ng then names five things a skilled developer should be able to do. This is his structure, not mine.

Building full-stack applications

Agentic coding lets a front-end specialist work across the whole stack, but you still need to understand what the full stack does. Ng lists the components: UI components, caching, page rendering, API choice and design, authentication, state and session management, asynchronous processing, data persistence, testing, security, and accessibility.

Managing data

Data gets its own section because it is hard to change once software is built on top of it. The agent only knows what the data model tells it, so a poorly chosen architecture means the agent does not know what it does not know. Access patterns, storage types, transactions, concurrency, and the data lifecycle all feed decisions about speed, scalability, reliability, and cost.

Designing system architectures

Once you understand the components, you can decide how to put them together. Ng frames architecture as a set of tradeoffs: how many users, how important latency is, how important cost is, monolith versus microservices, which stack to pick. The right answer also shifts as a project goes from prototype to production to scale.

Making systems secure and reliable

Reliability means a testing strategy and a plan for failure: the mix of unit and integration tests, handling rate limits, graceful degradation, and keeping the blast radius small. Security is moving earlier in the lifecycle, in what Ng calls the "shift left" movement. AI can scan for vulnerabilities and check dependencies, but using those tools well still takes some security knowledge.

Scaling and operating in production

The last skill is the software development lifecycle: deployment, release strategy, CI/CD, observability, alerts, and incident management, then scaling through load balancing, sharding, indexing, and replication. Ng ends with the practices that keep a system evolving: version control, code reviews, dependency maintenance, and technical debt.

The point he lands on

The article closes on its sharpest claim. Some parts of coding knowledge, like memorizing syntax, are becoming obsolete. But developers who deeply understand how software works vastly outperform those who vibe code without understanding. Understanding the fundamentals also tells you what software can and cannot do, which is the context you need to use a coding agent well in the first place.