If you keep hearing that developers must work with AI but cannot tell whether that means training models or building products, the AI engineering layers answer it. The stack has three layers, and the developer's layer is the application layer.
What Are the 3 AI Engineering Layers?
The three AI engineering layers are infrastructure, model, and application, and developers belong at the application layer. The framing comes from an article called the AI Engineering Stack published by The Pragmatic Engineering newsletter in 2025, which Wesley Willians of the Full Cycle channel used to explain where software developers fit in the AI economy. Each layer demands a different specialization, and confusing them is why many developers assume AI work is out of reach.
Read from the bottom up, the stack looks like this:
| Layer | Focus | Who works there |
|---|---|---|
| Infrastructure | GPUs, compute, training clusters | Hardware and systems specialists |
| Model | Data, training, inference, reliability | ML and data science engineers |
| Application | AI interfaces, prompts, context, evaluation | Software developers and AI engineers |
The source article also draws a practical distinction: machine learning engineering moves from data to model to product, while AI engineering starts from the product and works downward into data and models. That inversion is the core reason a full stack developer can enter AI without ever training a model.
How AI Engineering Differs from Machine Learning
AI engineering uses models that other people trained, so it focuses less on modeling and training and more on adapting models to products. A machine learning engineer traditionally worries about datasets, training pipelines, and whether a model is reliable at inference. An AI engineer starts with the product and asks which existing model fits.
The work also differs in the shape of the output. Classic machine learning answers narrow questions: is this a dog or a cat, is this message spam, what sentiment does this text carry. Large models produce open-ended output. The same Gemini or ChatGPT model can answer questions about programming, medicine, or law, which means evaluation and control become engineering problems rather than fixed classification metrics.
None of this makes the model layer irrelevant. Developers should understand what layers below them do, the same way a web developer benefits from knowing how a database works. The priority, though, sits at the top.
The Application Layer: AI Interfaces and Their Categories
The application layer is where the developer's role lives, and its first concern is the AI interface: how the end user interacts with the model. That user can be a human, another AI, or software calling the model programmatically. As computing evolves, interfaces shrink, from desktop machines to phones to watches to audio-only interactions where the AI does the work behind the scenes.
The AI Engineering Stack article groups AI interfaces into recognizable categories:
- Standalone AI software, where AI is the product itself, as with ChatGPT.
- Embedded AI, where AI is plugged into existing software, such as GitHub Copilot as a VS Code extension.
- Chatbots, where users converse with the model continuously.
- Agents, a distinct category covered later in this article.
A recurring confusion separates chatbots from agents. A chatbot can be implemented as an agent, but not every agent is a chatbot. An agent perceives its environment, knows its tools and context, plans actions, and decides autonomously; a chatbot mostly reacts to messages.
Prompt Engineering and Context Construction
Prompt engineering and context construction control model behavior by deciding what you ask and what background the model receives. Everyone knows prompts matter; far fewer actively study prompt types, structure, and the documentation needed to produce good context. The gap shows directly in results.
Willians recounts a benchmark episode involving Google's Gemini and OpenAI's ChatGPT. In his telling, Gemini scored around 90 percent on a benchmark and appeared to beat ChatGPT, until observers noticed Google had used a chain-of-thought prompt with roughly 32 worked examples while OpenAI's published run used only 5. When the same extensive prompting was applied to ChatGPT, its score improved too, and Gemini given only 5 examples scored below ChatGPT. The exact numbers come from the video speaker's recollection, so treat them as a first-hand account rather than an independent benchmark record. The lesson survives the uncertainty: the same model can rank above or below a competitor depending on prompt construction alone.
The implication for developers is plain. If you do not study prompt types and context strategies, results stay poor no matter which model you pick, and the model gets the blame that belongs to the prompt.
Evaluation: Reducing Risk When Software Stops Being Deterministic
Evaluation is the discipline of verifying what the AI actually produces in your application, and its main job is risk reduction. Traditional code runs through deterministic ifs and elses, so developers control every path. AI decides on its own and can take paths nobody predicted, which breaks that assumption.
Willians argues evaluation is where developer awareness is lowest. Working evaluation covers several concrete practices:
- Selecting the right, often specialized, model for each task.
- Comparing models with benchmarks to cut cost, since the best model is not always worth its price.
- Understanding context windows, tokens, and embeddings.
- Working with protocols such as the Model Context Protocol when agents need tools.
- Adjusting deployment of AI features and hunting for output improvements, sometimes by changing nothing but the prompt.
That last point deserves emphasis. Small, deliberate prompt changes can produce large improvements in software behavior, which turns evaluation into a continuous loop rather than a one-time QA pass.
Agents: The New Software Developers Must Learn to Build
An AI agent is a software entity that perceives its environment, plans actions, and makes autonomous decisions to complete tasks. It is still software with code, tests, and deployment, much like microservices were a decade ago when engineers struggled to explain how they differed from ordinary systems.
The defining difference between an application that merely calls AI and an agent is decision-making authority. In an agent, the AI is the core of the application's decisions. It runs an LLM call, reads the result, then calls a tool, an MCP server, another agent, delegates the task, or retries. It acts proactively, not just reactively. At Microsoft Build, the company demonstrated an SRE agent that detected a Redis problem in a running system, diagnosed it, and asked a human for a single click before resolving the issue largely on its own.
Agentic coding tools are already shipping this pattern in production. GitHub Copilot performs code reviews, Claude Code from Anthropic runs agentic coding tasks in the terminal, and Cursor and Windsurf build agentic workflows into the editor. Frameworks for coordinating teams of agents that negotiate in natural language are spreading fast.
Willians closes with a career warning framed as competition, not replacement: the risk is not that a company fires you and hires an AI, but that every teammate works five times faster because they mastered AI workflows. Developers who only scratch the surface, typing one request into GitHub Copilot and hoping for a fix, are competing against people who use structured workflows, activity-specific prompts, and architecture knowledge to direct AI systems.
Frequently Asked Questions
- Do developers need to learn machine learning to work with AI? No. Developers work at the application layer of the AI engineering stack, using models others trained. Understanding the layers below helps, but training models is a separate specialization.
- What is the difference between an AI agent and a chatbot? A chatbot reacts to user messages, while an agent perceives its environment, plans actions, chooses tools, and decides autonomously. A chatbot can be built as an agent, but not every agent is a chatbot.
- Why do AI benchmark results change with prompting? Prompt construction, such as adding chain-of-thought examples, directly changes model performance. The video's Gemini versus ChatGPT anecdote shows ranking can flip based on how many examples each system was given.
- Which AI layer should a full stack developer prioritize? The application layer: AI interfaces, prompt engineering, context construction, and evaluation. This is where products are built and where existing developer skills transfer fastest.
Turn Your Own AI Explainers Into Written Articles
This article exists because one 26-minute video laid out the three AI engineering layers clearly enough to deserve a written record. If you explain ideas like these on YouTube, whether about agents, prompts, or architecture, that knowledge stays locked in a format people must watch to the end to search or cite.
Skala Blog turns a YouTube video into a structured blog article: paste the URL, get a transcription, and generate a publishable draft you control. Your best explanations should be readable, not just watchable.
Fork this article
Start a new branch from the same video, shaped your way. You keep the credit; the original keeps the attribution.
A fork in another language is filed as a translation of this article, so the two pages point at each other. You can unlink it later from the editor.
0/240
You are creating
- Format
- For
- Language
- Source
- Your angle
You will be asked to sign in before it is generated.
Buy credits