From Prompts to Systems: How AI Engineering Changed Between 2023 and 2026

Tue, 11 Aug 2026 00:00:00 +0000

Between 2023 and 2026, the practice of building with large language models shifted from writing better prompts to designing better systems. The model itself was once the entire product. Now it is one component inside a much larger architecture that includes retrieval pipelines, memory layers, tool orchestration, evaluation harnesses, guardrails, and cost management.

This transition reflects a deeper conceptual change: success with AI is no longer about asking the right question. It is about building the right infrastructure around an imperfect reasoning engine.

The 2023 Mental Model

The early interaction pattern with LLMs was straightforward:

The dominant workflow was conversational. A user typed a prompt, received a response, and iterated. The primary skill was prompt engineering: knowing how to phrase instructions, set roles, provide few-shot examples, and manage token budgets. The model did the reasoning, and the user’s responsibility ended at crafting good input.

This worked well for single-turn tasks: drafting emails, summarizing papers, answering factual questions. But it broke down rapidly when applied to tasks requiring multiple steps, external data access, persistent state, or verifiable correctness.

The 2026 Mental Model

By 2026, the dominant workflow is architectural:

The workflow now looks more like systems design than conversation design:

Define the task and decompose it into subtasks.
Assemble the right context dynamically from retrieval, memory, and structured data.
Let the system retrieve, reason, invoke tools, and verify its own outputs.
Monitor quality, latency, and cost across every component.
Improve the system continuously through evaluation-driven iteration.

What Changed, Layer by Layer

Context Engineering Replaced Prompt Engineering

In 2023, “prompt engineering” meant crafting static instruction strings. By 2026, the term has largely been superseded by context engineering: the practice of dynamically assembling the full input window from multiple sources at inference time. This includes retrieved documents, structured metadata, conversation history, tool outputs, and system instructions, all composed programmatically rather than written by hand.

The distinction matters because static prompts break as soon as the task requires information the prompt author did not anticipate. Context engineering treats the prompt as a computed artifact, assembled from live data sources based on the current query.

Retrieval Became a First-Class Engineering Problem

Early retrieval-augmented generation (RAG) pipelines were often naive: embed documents, store vectors, retrieve top-k, concatenate into the prompt. This approach suffered from chunk boundary errors, irrelevant retrieval, and poor handling of multi-hop reasoning.

By 2026, retrieval pipelines incorporate re-ranking models, hybrid search (combining dense embeddings with sparse keyword indices), query decomposition, and iterative retrieval where the model reformulates its own search queries based on partial results. The retrieval layer is now treated as a system that must be evaluated, versioned, and optimized independently of the language model.

Tool Use Moved from Novelty to Necessity

Function calling and tool use were experimental features in 2023. By 2026, they are foundational. Models routinely call APIs, execute code, query databases, browse the web, and operate within file systems. The Model Context Protocol (MCP) emerged as a standardized interface for connecting language models to external tools and data sources.

This shift changes what LLMs can do: instead of only generating text about a topic, they can take actions within a software environment. The engineering challenge moved from “Can the model call a function?” to “How do we define, scope, and permission tool access safely?”

Agentic Systems Replaced Single-Turn Interactions

Single-turn question-answering gave way to multi-step, goal-directed agent loops. An agent receives a task, decomposes it into subtasks, executes them sequentially or in parallel (potentially delegating to sub-agents), observes the results, and iterates until the objective is met or a stopping condition is reached.

This architectural pattern introduces new failure modes: agents can loop indefinitely, take incorrect actions with real-world consequences, or accumulate errors across steps. Managing these failure modes requires explicit loop budgets, verification checkpoints, and human-in-the-loop escalation paths.

Evaluation Became Non-Negotiable

In 2023, most LLM applications shipped without systematic evaluation. By 2026, evaluation harnesses are standard infrastructure. These include automated test suites that compare model outputs against reference answers, regression tests that detect quality degradation after prompt or model changes, and domain-specific metrics that go beyond generic accuracy scores.

Without evaluation, teams cannot distinguish between a system that works and a system that appears to work. The difference becomes visible only at scale, when edge cases, distribution shifts, and adversarial inputs expose latent failures.

Guardrails and Observability Became Production Requirements

Deploying an LLM without guardrails in 2023 was common. By 2026, production systems require input validation (blocking prompt injection, enforcing schema compliance), output validation (detecting hallucinations, enforcing format constraints), and safety layers (content filtering, PII detection).

Observability tools provide trace-level visibility into every step of a multi-component pipeline: which documents were retrieved, what tool calls were made, how long each step took, and where failures occurred. This infrastructure is borrowed directly from distributed systems engineering and applied to probabilistic AI pipelines.

Cost Optimization Became a Design Constraint

Large model inference is expensive. Production systems now routinely implement model routing (sending simple queries to smaller, cheaper models and complex queries to larger ones), response caching, prompt compression, and knowledge distillation (training smaller task-specific models from larger model outputs). The economic viability of an AI product depends as much on inference cost management as on output quality.

What “Being Good at AI” Now Means

The competency profile for AI practitioners has expanded significantly:

2023 Competency	2026 Competency
Writing effective prompts	Designing context assembly pipelines
Choosing the right model	Selecting model routing strategies
Understanding tokenization	Building retrieval and re-ranking systems
Manual output review	Implementing automated evaluation harnesses
Ad hoc API calls	Orchestrating multi-agent tool-use workflows
Cost as afterthought	Cost as first-order design constraint

The field has become more interdisciplinary. Building a production AI system now requires elements of software engineering, distributed systems design, information retrieval, evaluation methodology, and ML operations, combined with enough domain expertise to define what “correct” means for the specific use case.

Prompting is Not Obsolete

Prompt construction remains important. Well-structured instructions, clear task decomposition, and appropriate few-shot examples still improve output quality. But prompting is now one component inside a larger system, not the system itself.

The best AI products in 2026 combine strong prompting with dynamic retrieval, persistent memory, verified tool use, automated evaluation, and continuous monitoring. The teams that build reliable AI products are the ones that treat the model as an inference engine embedded within an engineered pipeline, not as a standalone oracle.

Takeaways

2023 AI was about asking. 2026 AI is about orchestrating. The model is one layer in a multi-component architecture.
Context engineering superseded prompt engineering. Dynamic, programmatic context assembly replaced static instruction strings.
Evaluation is non-negotiable infrastructure. Without automated quality measurement, AI systems degrade silently.
Tool use and agentic loops changed what LLMs can do. Models now act within environments, not just generate text about them.
Cost optimization is a design constraint, not an afterthought. Economically viable AI requires model routing, caching, and distillation strategies.

Agentic Systems | Yassir Boulaamane