Andrew Ng: 5 Software Fundamentals AI Engineers Must Master in the Agent Era

https://x.com/AndrewYNg/status/2093388974194872781

How does agentic programming change software engineering fundamentals? Even if you use coding agents to write all your code, understanding software fundamentals remains critical for guiding your agent to make the trade-offs you want—or even knowing what trade-offs exist. Moreover, when you build AI applications, the AI core often expresses itself through a broader software application, which is the part you may want to help build or shape.

A novice who lacks software fundamentals and codes purely by intuition can create simple applications, but this often leads coding agents to make poor trade-offs around latency, availability, consistency, reliability, maintainability, simplicity, and/or cost. In such cases, the developer does not even know these trade-offs exist and therefore fails to steer the agent toward the right decisions for their use case.

This article lays out what our research on AI engineering skills shows are the most important knowledge points in software engineering. It requires proficiency in five areas:

Building full-stack applications

Managing data

Designing system architecture

Ensuring system security and reliability

Scaling and operating in production

01 Building Full-Stack Applications

Agentic coding enables many developers who previously held specialized roles—such as frontend or mobile developers—to take on broader full-stack roles. Coding agents can help you handle parts of development you may be less familiar with. However, understanding how the full stack actually works is crucial. Proficient developers understand key components and concepts of both frontend and backend systems, including UI components, caching, page rendering, API selection and design, authentication, state and session management, asynchronous processing, data persistence, testing, security, and accessibility.

02 Managing Data

Data deserves special attention because it is the foundation of software construction and is relatively difficult to change (even with agent-assisted migration). When you know how to manage data, you can reason about access patterns and use them to decide what to store and for how long. You can determine the right data model, choose the appropriate storage type (such as relational tables, documents, key-value, or graph) and infrastructure, which in turn affects speed, scalability, availability, reliability, and cost. You understand transactions, concurrency, and how to ensure data is clean, consistent, and fresh. When necessary, you can ensure appropriate privacy, governance, and compliance. You know how to manage the data lifecycle.

As applications evolve, you also know how to evolve the data architecture alongside them. Deciding how to manage data requires substantial human-provided context. Your AI system will draw its own input context from data sources, so if the data architecture is chosen poorly, the AI will not know what it does not know. This is why a skilled, AI-engineering-proficient human—you—must intervene to correct it. How to build data infrastructure for agents—not just for traditional software or humans—is also a rapidly evolving area, and you should adapt your best practices as the field advances.

03 Designing System Architecture

Once you understand the major components of the software and data full stack, you are better equipped to decide how to assemble them. Good system design requires understanding the software's intended purpose (how many users? how important is latency? how important is cost? etc.) so you can make choices about the application platform, boundaries between frontend and backend, system decomposition, where application state lives, and architectural granularity (monolith vs. microservices). You also need to select the technology stack (programming languages, runtimes, component/frontend/backend frameworks, data technologies)—sometimes by running experiments to evaluate options before committing.

Moreover, the right architecture is a moving target that depends on the project stage. The simple architecture you choose to build a prototype quickly may not be the right architecture for the first production system, and it may change again as the application scales. Making these decisions demands deep technical understanding of both software components and application context so you can design—and evolve—an architecture that makes better trade-offs.

04 Ensuring System Security and Reliability

To build reliable systems, you should know how to devise a testing strategy that verifies system correctness: the mix of unit and integration tests, which frameworks to use, and what coverage levels to target. You also know how to design around potential failures—how to handle failures (e.g., when an API hits rate limits), build graceful degradation, and minimize blast radius. Additionally, rather than writing software first and then thinking about how to secure it, the "shift-left" movement is moving security earlier in the lifecycle (left on a traditional project timeline). Just as all developers are becoming full-stack developers, many developers now also partially take on the role of security engineers. You can now use AI tools to scan code for vulnerabilities, check dependencies for supply-chain injections, and review cloud configurations for attack surface. But doing this well still requires security knowledge.

05 Scaling and Operating in Production

To serve real users, you must know how to deploy software to production. Understanding the software development lifecycle (SDLC) serves you well: beyond building and testing, it includes configuring deployment environments, deciding release strategies, automating deployment (CI/CD), and understanding infrastructure as a service (IaaS).

Operating in production requires deploying observability tooling, setting up alerts, and managing incidents. Finally, to scale an application, you should understand real-world load, know how to scale servers, perform load balancing, and tune data infrastructure (via sharding, indexing, replication) or make architectural changes so the system adapts to scaling demands. Lastly, understanding coding best practices—version control, code review, dependency maintenance, and how to manage technical debt—helps you continuously evolve the system over the long term.

Coding agents change how we build software, including software that contains no AI components. Parts of coding knowledge—such as memorizing syntax—are becoming obsolete. But developers who deeply understand how software works far outperform those who code by intuition without that understanding.

Understanding software fundamentals (and AI) also helps you figure out what software can and cannot do. This makes them important context for how you use coding agents and how you shape the building process. I will discuss these issues in subsequent articles.