---
title: "Agentic Engineering: What It Is and How It Differs From Prompting"
url: https://syntaxradar.com/radar/from-prompt-engineering-to-agentic-engineering-tech-stack
author: "Abdul Rehman, Lead Systems Architect and Technical Director"
publishedAt: 2026-10-24T06:00:00.000Z
dateModified: 2026-10-29T10:33:58.900Z
category: "#DEV-SYSTEMS"
topic: "agentic engineering"
primarySource: https://simonwillison.net/guides/agentic-engineering-patterns/what-is-agentic-engineering/
summary: "Agentic engineering explained for non-engineers: how it differs from prompt engineering and vibe coding, what agents need, and how teams test them."
---


# Agentic Engineering: What It Is and How It Differs From Prompting

**Short answer:** Agentic engineering, building software with coding agents that run tools in a loop, is replacing single-prompt tricks as the way teams work with AI.

**Takeaway:** Agentic engineering is the discipline around the model, meaning tools, memory and tests, and Anthropic advises adding agents only when a simpler design falls short.

**Key figures (as reported by the source):**
- Agent definition (Simon Willison): Runs tools in a loop to achieve a goal
- Starter eval set (Anthropic): 20 to 50 simple tasks
- Anthropic's pass-three-in-a-row example: About 42% at 75% per trial

Agentic engineering is the practice of building software with the help of coding agents: programs that write code, run it, read the result and try again. Prompt engineering is the craft of wording a single request to a language model. The two overlap, but they describe different jobs, and the second is now a small part of the first.

The term is young, and people use it in more than one way.

### What is agentic engineering?

Developer Simon Willison defines it as [developing software with the assistance of coding agents](https://simonwillison.net/guides/agentic-engineering-patterns/what-is-agentic-engineering/). He defines an agent in one line: it runs tools in a loop to achieve a goal. In practice, a program asks a language model what to do, runs the tool the model picks (such as a code editor or a test runner), feeds the output back, and repeats.

Willison says the ability to run code is what makes the approach work, because an agent can check whether its own output functions. The human still decides what to build, supplies the tools, describes the problem in enough detail and verifies the result.

Andrej Karpathy, who coined "vibe coding" in February 2025, is widely reported to have proposed "agentic engineering" a year later as a better name for the professional version of the practice. Reports quote him as saying "agentic" fits because you are not writing the code directly most of the time, and "engineering" signals that skill is involved.

### How is agentic engineering different from prompt engineering?

Prompt engineering is about how to write and organize the instructions you give a model. Anthropic describes [context engineering](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) as its natural progression: deciding which information the model sees at each step, which goes well beyond the wording of one prompt.

This practice sits one level higher. The prompt is still there, but so are the tools the agent can call, the memory it keeps between steps, the checks that decide whether its work is accepted, and the person who reviews the outcome.

A language model is the AI system that predicts text. A harness is the surrounding program that feeds the model information, runs its tool requests and handles errors. One secondary source separates "agent engineering" (building that harness) from agentic engineering (using agents to build software). Others use the words interchangeably, so check which meaning an author intends.

![A developer at a desk reviewing a long list of code changes on a monitor while a laptop beside them shows a running test](https://images.unsplash.com/photo-1526374965328-7f61d4dc18c5?w=1600&auto=format&fit=crop&q=80)

### What does the agentic engineering stack look like?

No official standard defines an agentic engineering stack. Four ingredients show up repeatedly.

The first is the model itself, which reasons about the task and decides the next step. The second is the tools, which let it act: reading files, searching, running code. Anthropic's guidance says tool design deserves as much care as prompt design, and suggests making tools harder to misuse, for example by requiring absolute file paths.

The third is memory and context. Anthropic names several techniques: compaction (summarizing a long conversation and restarting from the summary), structured note-taking (the agent writes notes outside its context window and reads them back later), and sub-agents that work in clean context windows and return short summaries.

The fourth is verification, covered below. Everything else, including the choice of framework, is secondary to those four. A team that gets the tools and tests right can swap the model later; a team that skips them has little way to tell whether a new model is better or worse.

### Do you need an agent at all?

Often the answer is no. Anthropic's essay on [building effective agents](https://www.anthropic.com/engineering/building-effective-agents) advises starting with the simplest solution and adding complexity only when needed. It notes that agentic systems trade latency and cost for better task performance, and that an agent's autonomy brings higher costs and the potential for compounding errors.

The essay draws a line between two designs. Workflows are systems where models and tools follow predefined code paths. Agents are systems where the model directs its own process and tool use. Workflows suit well-defined tasks. Agents suit open-ended problems where the number of steps cannot be predicted in advance.

Anthropic lists patterns inside the workflow side, including prompt chaining (a task split into sequential model calls), routing (sorting an input to a specialized follow-up) and parallelization (running subtasks at the same time). It also lists an evaluator-optimizer pattern, where one model produces a response and another critiques it in a loop.

On frameworks, the same essay says they simplify common tasks but can obscure the underlying prompts, which makes debugging harder. Its advice is to start by calling model APIs directly.

![A small workshop bench with a half-assembled robotic arm, hand tools and a handwritten checklist pinned to the wall](https://images.unsplash.com/photo-1526374965328-7f61d4dc18c5?w=1600&auto=format&fit=crop&q=80)

### How do you test an AI agent?

Anthropic's guide to [evals for AI agents](https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents) defines an eval as a test: you give the agent an input, then apply grading logic to what it produces.

Agents are harder to test than a single prompt because they use tools across many turns, change state along the way and can compound early mistakes. Anthropic calls one test a task and each attempt at it a trial. Teams run several trials because results vary from run to run.

The guide describes three kinds of graders. Code-based graders (pass/fail tests, string matching) are fast, cheap and objective but brittle. Model-based graders use another model with a scoring rubric, which handles open-ended work but is less predictable and needs calibration against human judgment. Human graders are the gold standard but slow and costly.

Anthropic suggests starting with 20 to 50 simple tasks drawn from real failures. It also warns against grading the path an agent took instead of the result, and recommends reading the transcripts (the full record of a trial) to confirm the eval is fair.

Reliability needs care. The guide gives an example: an agent that passes a task 75% of the time per trial has about a 42% chance of passing three trials in a row, which is 0.75 multiplied by itself three times.

### Is agentic engineering just vibe coding with a new name?

Willison argues no. He wants "vibe coding" to keep its narrow meaning from Karpathy's original post: prompting a model while you forget the code even exists, which he associates with unreviewed, prototype-quality output. The practice, in his framing, aims at code held to a production standard, with verification and iteration treated as central.

Reports of a Sequoia event describe Karpathy using a similar split, with vibe coding raising the floor (anyone can build software) and agentic engineering raising the ceiling.

There is a real disagreement in the secondary coverage about whether vibe coding is finished or simply one end of a range. Both can be true: a weekend prototype and a payment system warrant different levels of review.

### What to watch next

Anthropic's own essay notes that much of the tooling it describes has changed since December 2024 and points readers to newer documentation, which shows how fast this area moves. Specific products named in any "stack" list are likely to date quickly. One thing to watch is whether the vocabulary settles, since "agent engineering," "agentic engineering" and "context engineering" are still used loosely. Another is how teams publish eval results, because claims about agent reliability mean little without the task set and grading method behind them. A third is how coding agents are run in isolated environments, a topic covered in our look at [sandboxes for untrusted AI code](/radar/sub-millisecond-sandboxes-docker-wasm-micro-vms-untrusted-ai-execution).

For a related view of how agents are kept from running away, see our piece on [state maps that stop infinite loops](/radar/deterministic-state-graphs-preventing-infinite-loops-ai-agent-workflows).

## Frequently asked questions

### What is agentic engineering in simple terms?
Agentic engineering means building software with coding agents, which are programs that write code, run it, read the results and try again. According to developer Simon Willison, the human still decides what to build, provides the tools, describes the problem in detail and verifies the output until it can be trusted. The agent does the repetitive typing and testing.

### Is prompt engineering obsolete?
Not according to Anthropic, which calls context engineering the natural progression of prompt engineering. Writing clear instructions still matters. What changed is scope: agent builders now also manage tools, memory, what information the model sees at each step, and tests.

### How is agentic engineering different from vibe coding?
Willison keeps vibe coding to its original meaning: prompting a model while forgetting the code exists, usually yielding unreviewed prototypes. Agentic engineering, in his framing, targets production-quality code and treats verification and iteration as central. Commentators disagree on whether vibe coding is finished or just one end of a range, since prototypes and critical systems need different review.

### Do I need an AI agent or is a simple workflow enough?
Anthropic advises starting with the simplest solution and adding complexity only when needed, which often means not using an agent at all. Workflows follow predefined code paths and suit well-defined tasks. Agents choose their own steps and suit open-ended problems, but they cost more, run slower and can compound errors across steps.

## Source
Based on Anthropic engineering guides and Simon Willison. https://simonwillison.net/guides/agentic-engineering-patterns/what-is-agentic-engineering/

---
Published on SyntaxRadar (https://syntaxradar.com). Canonical URL: https://syntaxradar.com/radar/from-prompt-engineering-to-agentic-engineering-tech-stack. Last modified 2026-10-29T10:33:58.900Z.