Supabase Library · Published 2026-10-12

Andrew Ng on Coding Agents and Deciding What to Build

Open on YouTube ↗

Summary

Overview

  • Speaker: Andrew Ng
  • Channel: Supabase Library
  • Main topic: AI Coding Agents and the Future of Software Engineering and Infrastructure
  • Purpose: To provide insights into how AI coding agents are reshaping software engineering skills, infrastructure demands, and the workflow of developers. Andrew Ng discusses the future of databases, infrastructure demand driven by AI agents, skill mapping for AI engineering, the transition from coding to deciding what to build, and the limitations of LLMs in education.

Topic Map

Future of Databases and Infrastructure Demand

  • Explanation: Ng discusses how AI agents will consume compute and storage infrastructure at scale, driving massive demand beyond human usage.
  • Key claims:
    • Infrastructures like compute and storage will be used heavily by agents, not just humans.
    • Agentic usage of infrastructure will drive massive demand.
    • Database architectures built for human query patterns will need to scale for agentic queries.
  • Examples:
    • Training and inference data center buildouts for AI agents.
  • Terminology:
    • agentic usage
    • core infrastructure
    • inference data center
  • Why it matters: Highlights hidden drivers of infrastructure growth that many industry observers overlook.

AI Engineering Skills Map

  • Explanation: DeepLearning.AI analyzed 10,000 job descriptions, structure interviews, and surveys to identify four key skills needed for AI engineering.
  • Key claims:
    • AI engineering skills apply across multiple job roles (frontend, backend, DevOps, mobile).
    • Four key skills: building and deploying AI apps with uncertainty management, software engineering fundamentals for coding agents, agentic coding, and shaping the build.
  • Examples:
    • Using coding agents to steer code instead of writing raw code.
  • Terminology:
    • AI engineering
    • coding agents
    • shaping the build
    • uncertainty management
  • Why it matters: Helps developers understand how to upskill in an era where AI writes much of the code.

Cognitive Offloading in Education

  • Explanation: Discussion on how LLMs affect student learning through cognitive offloading.
  • Key claims:
    • Cognitive offloading to LLMs (having LLMs think for you) results in getting more work done but learning less.
    • Rigor studies in K-12 and higher education show that offloading thinking hinders deep skill acquisition.
  • Examples:
    • Students using LLMs to do homework get better output faster but score worse on final exams.
  • Terminology:
    • cognitive offloading
    • LLM
    • rigorous studies
  • Why it matters: Balances the enthusiasm for AI productivity tools with empirical realities about human skill retention.

Key Points

Agentic Infrastructure Demand

  • Explanation: AI agents will drive exponentially higher demand for compute and storage than human users alone.
  • Evidence: Feedback from builders showing compute shortages and massive scaling needs.
  • Practical implication: Cloud providers and infrastructure companies must prepare for non-human agent workloads.

Shaping the Build over Coding

  • Explanation: Developers are shifting from line-by-line coding to participating in product decisions and steering coding agents.
  • Evidence: Observed market trends in developer workflows and job descriptions.
  • Practical implication: Product intuition and architectural thinking become more valuable than raw syntax memorization.

Cognitive Offloading Trade-offs

  • Explanation: Using AI to do all thinking speeds up short-term output but reduces long-term learning and foundational mastery.
  • Evidence: Recent rigorous educational studies on LLM usage by students.
  • Practical implication: Educators and professionals must carefully balance AI delegation with deliberate practice.

Frameworks, Models & Processes

AI Engineering Skills Map

  • How it works: Categorizes the essential competencies required for engineers working alongside AI agents.
  • Components:
    • Building and deploying AI applications with uncertainty
    • Software engineering fundamentals
    • Utilizing coding agents effectively
    • Shaping the build (product and architectural decisions)
  • When to use: When upskilling developers for AI-augmented software development roles.

Examples & Case Studies

Analyzing 10,000 job descriptions and structural interviews at DeepLearning.AI.

  • Illustrates: Mapping out the exact skill gaps between traditional software engineering and AI engineering.
  • Lesson: Identifying four core pillars required for effective AI engineering.

Actionable Takeaways

  • Immediate:
    • Adopt coding agents to accelerate development workflows.
    • Focus on software engineering fundamentals to better steer AI coding tools.
  • Strategic:
    • Anticipate infrastructure scaling driven by agentic workloads.
    • Balance AI productivity tools with foundational learning to avoid cognitive atrophy.
  • Questions to investigate:
    • How will database architectures evolve to handle non-human agent query loads?
    • What new educational frameworks are needed to ensure human skill retention alongside AI tools?

Claims Worth Verifying

  • Cognitive offloading to LLMs increases task output while reducing individual learning retention. (empirical)
  • Demand for core compute and storage infrastructure will scale dramatically due to autonomous AI agents. (technological projection)

Notable Quotes

"I suspect something that a lot of the world does not yet appreciate is that in the future, a lot of core infrastructure, be it compute, storage, will be used not just by humans, but by agents." (at 0:18) "I actually don't miss coding by hand." (at 18:52)

Compressed Summary

  • AI agents will drive unprecedented non-human infrastructure demand for compute and storage.
  • The AI engineering skills map identifies uncertainty management, software fundamentals, agentic coding, and build shaping as critical.
  • Cognitive offloading via LLMs increases short-term productivity at the expense of deep learning.
  • Keywords: ai agents, coding agents, infrastructure, skills map, cognitive offloading
  • Core insight: AI coding agents are shifting developer roles from raw implementation to high-level system shaping and architectural decision-making.

Core insights

5
Architecturehigh noveltymoderate evidence

Autonomous agents will become a distinct class of infrastructure consumer: compute and storage will be used 'not just by humans, but by agents,' and database architectures built for human query patterns will need to scale for agentic query loads.

Why it matters

Reframes capacity planning and database design: the workload profile of agent-driven queries (volume, concurrency, non-interactive access patterns) is a different design target than human-optimized systems, so teams building agent runtimes may inherit scaling assumptions that no longer hold.

Generalization

Whenever a new non-human client class (batch jobs, crawlers, agents) becomes a first-order consumer of shared infrastructure, existing systems tuned for interactive human usage become bottlenecks and need re-architecture around the new access pattern.

a lot of core infrastructure, be it compute, storage, will be used not just by humans, but by agents
Open source video
Database architectures built for human query patterns will need to scale for agentic queries.
Open source video
Mental Modelmedium noveltymoderate evidence

An AI engineering skills map derived from analyzing 10,000 job descriptions and structured interviews converges on four competencies: building/deploying AI apps with uncertainty management, software engineering fundamentals, agentic coding, and shaping the build — and these apply across frontend, backend, DevOps, and mobile roles.

Why it matters

Provides a concrete, evidence-derived taxonomy for role design and upskilling rather than generic 'learn AI' advice, and implies that agent-skill requirements cut across traditional role silos rather than concentrating in one new job title.

Generalization

When a new capability diffuses across engineering, it re-expresses itself inside every existing role instead of creating a single new role — so capability planning should be horizontal, not a dedicated headcount bucket.

DeepLearning.AI analyzed 10,000 job descriptions, structure interviews, and surveys to identify four key skills needed for AI engineering.
Open source video
AI engineering skills apply across multiple job roles (frontend, backend, DevOps, mobile).
Open source video
Four key skills: building and deploying AI apps with uncertainty management, software engineering fundamentals for coding agents, agentic coding, and shaping the build.
Open source video
Tradeoffmedium noveltystrong evidence

Cognitive offloading to LLMs is an output/learning tradeoff: delegating thinking produces more completed work faster but measurably reduces skill acquisition and exam performance.

Why it matters

Treats delegation to an agent as a capability-substitution decision with a measurable cost, not a pure productivity multiplier — relevant to how teams decide what to hand to agents versus what humans must continue to practice.

Generalization

Any delegate-the-cognition workflow buys short-term throughput at the cost of the delegate's ability to build the underlying skill, so the boundary of delegation should be set by which skills must be retained, not by which tasks are automatable.

Cognitive offloading to LLMs (having LLMs think for you) results in getting more work done but learning less.
Open source video
Students using LLMs to do homework get better output faster but score worse on final exams.
Open source video
Mental Modelmedium noveltymoderate evidence

Developer work is shifting from line-by-line implementation to 'shaping the build' — participating in product decisions and steering coding agents — making product intuition and architectural thinking more valuable than syntax recall.

Why it matters

Changes what to evaluate and hire for: the scarce skill becomes specifying and steering the build, which affects tooling (agent harnesses, review workflows) and where human checkpoints belong in the pipeline.

Generalization

As generative systems absorb execution, the scarce input migrates one level up the abstraction ladder (from implementation to specification and selection), and the boundary of human work moves with it.

Developers are shifting from line-by-line coding to participating in product decisions and steering coding agents.
Open source video
Product intuition and architectural thinking become more valuable than raw syntax memorization.
Open source video
I actually don't miss coding by hand.
Open source video
Practicemedium noveltyweak evidence

Uncertainty management is treated as a first-class engineering competency for building and deploying AI applications, sitting alongside traditional software engineering fundamentals rather than replacing them.

Why it matters

Implies that AI app development needs explicit mechanisms for handling nondeterministic and unreliable behavior, and that classical SE discipline remains load-bearing under agentic coding rather than being obsolete.

Generalization

Systems whose core component is probabilistic demand a distinct discipline for bounding, observing, and containing uncertainty that is additive to, not substitutable for, conventional engineering rigor.

Four key skills: building and deploying AI apps with uncertainty management, software engineering fundamentals for coding agents, agentic coding, and shaping the build.
Open source video

Deep dives

5

Agent-class workloads as a distinct infrastructure consumer

Research question

Which human-tuned database design assumptions (latency targets, concurrency ceilings, indexing, caching, cost models) break first under agent-generated query loads, and what replacement patterns emerge?

Why

If agents become a first-order consumer of compute and storage, capacity planning, indexing and cost models built on human access patterns become unreliable, so teams building agent runtimes need to know exactly where their storage layer fractures and what to substitute.

a lot of core infrastructure, be it compute, storage, will be used not just by humans, but by agents
Open source video
Database architectures built for human query patterns will need to scale for agentic queries.
Open source video
Feedback from builders showing compute shortages and massive scaling needs.
Open source video
Source video

Boundary of delegation: which cognition to hand to agents and which to retain

Research question

Can a criterion for the delegation boundary be derived from which skills must be retained, and does it predict long-term capability better than delegating by task automability?

Why

The offloading tradeoff turns delegation into a capability-substitution decision with a measurable cost, so teams need a rule for where human checkpoints belong rather than treating agent delegation as a pure productivity multiplier.

Cognitive offloading to LLMs (having LLMs think for you) results in getting more work done but learning less.
Open source video
Students using LLMs to do homework get better output faster but score worse on final exams.
Open source video
Source video

Shaping the build as the new locus of engineering value

Research question

Does a 'shaping the build' competency (specification, product judgment, agent steering) predict engineering outcomes better than syntax proficiency, and what tooling and review surfaces does it require?

Why

Changes what teams evaluate and hire for and where human checkpoints sit in the pipeline: tooling shifts toward agent orchestration, spec quality and verification of agent output rather than authoring.

Developers are shifting from line-by-line coding to participating in product decisions and steering coding agents.
Open source video
Product intuition and architectural thinking become more valuable than raw syntax memorization.
Open source video
I actually don't miss coding by hand.
Open source video
Source video

Validating a four-competency AI engineering skills map against outcomes

Research question

Do uncertainty management, SE fundamentals, agentic coding and shaping the build predict measured engineering performance better than alternative skill taxonomies, and is the overlap across frontend/backend/DevOps/mobile roles empirically uniform?

Why

The map derives from job descriptions, interviews and surveys that capture stated requirements rather than validated performance, so headcount and upskilling plans built on it may be misallocated.

DeepLearning.AI analyzed 10,000 job descriptions, structure interviews, and surveys to identify four key skills needed for AI engineering.
Open source video
AI engineering skills apply across multiple job roles (frontend, backend, DevOps, mobile).
Open source video
Four key skills: building and deploying AI apps with uncertainty management, software engineering fundamentals for coding agents, agentic coding, and shaping the build.
Open source video
Source video

Uncertainty management as an additive discipline to classical software engineering

Research question

What mechanisms for bounding, observing and containing probabilistic behavior are required when a system's core component is nondeterministic, and do classical SE practices remain load-bearing rather than obsolete under agentic coding?

Why

If uncertainty management is additive to, not substitutable for, conventional engineering rigor, then AI app development needs explicit containment mechanisms and review gates that current pipelines may lack.

Four key skills: building and deploying AI apps with uncertainty management, software engineering fundamentals for coding agents, agentic coding, and shaping the build.
Open source video
Deploying AI apps requires bounded, observable handling of probabilistic behavior that agent workflows amplify.
Open source video
Source video

Article ideas

4

Your Database Was Built for Humans: Agent Query Loads Are a Different Design Target

Agentic query workloads are a distinct access pattern class — high-volume, non-interactive, differently concurrent — so human-optimized database assumptions about latency, indexing, caching and cost are not merely stressed but wrong, and teams should instrument agent workloads before they provision for them.

Angle

Take each human-tuned design assumption and show the failure mode under agent-generated load, then describe what a replacement design target looks like.

Source video

Delegation Is a Capability Trade, Not a Productivity Multiplier

Handing cognition to an LLM buys throughput at a measurable cost to the delegate's underlying skill, and the same trade runs through delegating coding to agents — so the delegation boundary should be set by which skills must be retained, not by which tasks happen to be automatable.

Angle

Argue the offloading finding generalizes from education to engineering practice, and propose a retention-first rule for deciding what humans keep doing.

Source video

Shaping the Build: Why the Scarce Skill Migrated One Level Up the Abstraction Ladder

As generative systems absorb execution, the scarce input moves from implementation to specification and selection, which means the tools and checkpoints that matter shift to agent orchestration, spec quality and verification of agent output — not authoring.

Angle

Trace how the boundary of human work moves when execution is absorbed, and map the concrete tooling and review surfaces that follow.

Source video

A Skills Map Built From Job Postings Is a Map of Wishes, Not of Performance

A four-competency AI engineering taxonomy derived from 10,000 job descriptions and surveys captures stated requirements, so it should be validated against measured outcomes before it drives hiring, role design or upskilling budgets — especially the claim that the skills apply uniformly across roles.

Angle

Critique the evidence basis and the uniformity assumption, then propose what an outcome-validated version would need to measure.

Source video

Project ideas

4

Agent-Load Database Fault Mapper

gatehouse

At least one specific design choice in human-tuned database engines (e.g. connection-pool sizing, cache eviction policy, interactive-latency indexing) degrades measurably faster under non-interactive agent-generated query loads than under an equivalently sized human interactive workload.

Proof of concept

Replay a synthetic agent workload (high-volume, non-interactive, bursty, retry-heavy) against a human-interactive baseline of equal total operations on the same engine, and instrument latency percentiles, pool saturation, index hit rates and cost per operation to locate the first breaking assumption.

Measurement

Ratio of degradation in p99 latency, saturation onset time and cost per query between agent-mode and human-mode workloads; identification of which specific configuration knob or design assumption breaks first.

Source video

Delegation Boundary Experiment Harness

movement-lab

For a fixed task class, the fraction of the task delegated to an agent determines near-term output but inversely predicts the human's retained ability to perform the same task unaided later — and a retained-practice split can hold output roughly flat while preserving capability.

Proof of concept

Split engineers across three arms (full delegation, partial delegation with a mandatory human-practice component, no delegation) on matched tasks, measure immediate output, then re-test capability unaided at a delay using held-out tasks of the same class.

Measurement

Immediate output volume and quality versus delayed unaided performance on held-out tasks, per arm; effect size of the retained-practice split relative to full delegation.

Source video

Shaping-the-Build Signal Audit

beyond-evals

In AI-augmented teams, hiring and promotion signals do not yet weight product intuition and architectural judgment above syntax proficiency, even though the stated work has shifted to steering coding agents and shaping the build.

Proof of concept

Code interview rubrics, promotion packets and hiring criteria for a sample of AI-augmented teams against how work is actually allocated between spec/judgment and implementation, exposing where signals still reward syntax recall.

Measurement

Correlation between rubric/promotion weightings and measured allocation of work to spec and judgment versus implementation, and the size of the stated-versus-actual gap.

Source video

Four-Competency Outcome Validation

new

The four competencies (uncertainty management, SE fundamentals, agentic coding, shaping the build) predict measured engineering outcomes better than alternative skill taxonomies, but their cross-role overlap is not uniform — it is concentrated in specific role types rather than spread evenly across frontend, backend, DevOps and mobile.

Proof of concept

Operationalize the four competencies into observable rubrics, score engineers across roles against both these and a control taxonomy, then regress scores on measured delivery outcomes and defect/incident rates to test predictive power and role uniformity.

Measurement

Comparitive predictive power (variance explained) of the four-competency model versus a control taxonomy, plus per-role competency distribution overlap and dispersion.

Source video

Architectural implications

2

Database architectures optimized for human query patterns are being asked to serve non-human agent query loads.

Before

Storage and query systems designed around interactive human access patterns (latency-tuned, moderate concurrency, human-paced).

After

Systems that must absorb high-volume, non-interactive, agent-generated query and storage loads as a first-order workload class.

Consequence

Capacity planning, indexing, caching, and cost models built on human usage assumptions become unreliable, requiring re-architecture for agentic access patterns.

Source video

Developer responsibility is moving from implementation to participating in product and architectural decisions while steering coding agents.

Before

Human writes code line by line; value concentrated in syntax fluency and implementation throughput.

After

Human specifies intent, steers agents, and makes product/architecture calls; value concentrated in judgment and system shaping.

Consequence

Tooling and review surfaces shift toward agent orchestration, spec quality, and verification of agent output rather than authoring.

Source video

Tradeoffs and failure modes

2

Cognitive offloading to LLMs

Benefit

More work completed and faster output on delegated tasks.

Cost or risk

Reduced individual learning retention and worse performance on assessments of underlying skill.

Cognitive offloading to LLMs (having LLMs think for you) results in getting more work done but learning less.
Open source video
Source video

Sustained agentic infrastructure demand

Benefit

Expanded infrastructure scale and investment driven by non-human workloads.

Cost or risk

Compute shortages and large scaling requirements that current provisioning may not anticipate.

Feedback from builders showing compute shortages and massive scaling needs.
Open source video
Source video

Open questions

4

How will database architectures evolve to handle non-human agent query loads?

Why unresolved

The summary asserts agentic query patterns will stress human-oriented designs but does not describe the mechanism or resulting architecture.

Research direction

Profile agent-generated query workloads against existing database engines to characterize concurrency, access patterns, and where human-tuned designs break.

Source video

What educational frameworks are needed to ensure human skill retention alongside AI tools?

Why unresolved

The summary reports the offloading tradeoff as an empirical finding but offers no mitigation or framework.

Research direction

Design and test interventions that preserve deliberate practice while using LLMs, measuring retention versus productivity.

Source video

Does the four-skill AI engineering map hold up across seniority levels and non-software roles?

Why unresolved

The map derives from job descriptions, interviews, and surveys, which capture stated requirements rather than validated on-the-job performance.

Research direction

Validate the four competencies against measured engineering outcomes rather than posted role requirements.

Source video

Which tasks should be delegated to agents versus retained for human practice?

Why unresolved

The productivity/learning tradeoff is stated directionally but without criteria for where to draw the delegation boundary.

Research direction

Build an experiment comparing delegated versus practiced task classes on both near-term output and long-term capability.

Source video

Key claims

8
predictionVerification needed

Core compute and storage infrastructure will increasingly be consumed by agents rather than only humans.

Evidence

in the future, a lot of core infrastructure, be it compute, storage, will be used not just by humans, but by agents

Question

What share of current production compute and storage workloads originates from autonomous agents versus human-initiated requests?

Source video
causalVerification needed

Agentic usage of infrastructure will drive massive demand.

Evidence

Agentic usage of infrastructure will drive massive demand.

Question

Do measured growth rates in compute/storage consumption attributable to agent workloads match the projected 'massive' scaling?

Source video
predictionVerification needed

Database architectures built for human query patterns will need to scale for agentic queries.

Evidence

Database architectures built for human query patterns will need to scale for agentic queries.

Question

Which specific database design choices fail under agent-generated query patterns, and what replaces them?

Source video
causalVerification needed

Cognitive offloading to LLMs increases task output while reducing learning retention.

Evidence

Cognitive offloading to LLMs (having LLMs think for you) results in getting more work done but learning less.

Question

Do controlled studies replicate the output-up / retention-down effect across contexts beyond K-12 and higher education?

Source video
opinionVerification needed

Four competencies define AI engineering: uncertainty management, software engineering fundamentals, agentic coding, and shaping the build.

Evidence

Four key skills: building and deploying AI apps with uncertainty management, software engineering fundamentals for coding agents, agentic coding, and shaping the build.

Question

Do these four competencies predict engineering performance better than alternative skill taxonomies?

Source video
comparativeVerification needed

AI engineering skills apply across frontend, backend, DevOps, and mobile roles.

Evidence

AI engineering skills apply across multiple job roles (frontend, backend, DevOps, mobile).

Question

Is the skill overlap across roles empirically uniform, or concentrated in specific role types?

Source video
causalVerification needed

Students using LLMs for homework produce faster/better output but score worse on final exams.

Evidence

Students using LLMs to do homework get better output faster but score worse on final exams.

Question

What effect sizes and confounders underlie the reported homework-versus-exam performance divergence?

Source video
comparativeVerification needed

Product intuition and architectural thinking become more valuable than raw syntax memorization.

Evidence

Product intuition and architectural thinking become more valuable than raw syntax memorization.

Question

Do hiring and promotion signals in AI-augmented teams actually weight architecture/judgment over syntax proficiency?

Source video

Connections

4