Agentic engineering

Agentic engineering is building software with AI coding agents while a professional stays in charge. The agent writes code and runs it to see whether it works. The developer decides what to build, describes it precisely and checks the result before it goes live. If you have software built for you, it is the difference between code that someone checked and code that an AI produced unreviewed.

Where does the term come from?

Andrej Karpathy coined vibe coding in February 2025: letting a language model write code while you "forget that the code even exists". A year later, in a post on X (February 2026), he wrote that programming via LLM agents was becoming a default workflow for professionals, with more oversight and scrutiny. His favourite name for it was agentic engineering: agentic because you mostly orchestrate agents that write the code and act as oversight, engineering because it is a skill you can learn and get better at.

In the same month Simon Willison started his guide Agentic Engineering Patterns. He defines the term as developing software with the assistance of coding agents, and keeps vibe coding for unreviewed, prototype-quality code.

How does it work?

A coding agent, such as Claude Code, OpenAI Codex or Gemini CLI, is an AI agent that can write and execute code. In Willison's words, an agent runs tools in a loop to achieve a goal. Running the code is the key capability: the agent can test its own work and keep iterating until the software demonstrably works. The developer's job shifts to giving the agent the right tools, specifying the problem at the right level of detail, and verifying the result.

Willison collects patterns that keep this under control:

• Red/green TDD: the agent writes a test first, confirms that it fails, then writes the code that makes it pass. This guards against code that does not work and code that is never used.
• "First run the tests" as the opening prompt of a session, so the agent knows there is a test suite and keeps using it.
• Git for every change, so mistakes can be traced and reversed.
• Updating the agent's instructions after a mistake. A language model does not learn from its errors; a coding agent can, if you write the lesson down (agent operational memory).

Where does it go wrong?

• Unreviewed code. Willison calls it an anti-pattern to open a pull request with agent-written code you have not reviewed yourself: you hand the real work to your colleagues.
• Cognitive debt. When nobody understands how the code the agents wrote works, planning new features gets harder, in the same way as with technical debt.

And agent engineering?

A similar-sounding term covers a different job. LangChain (December 2025) uses agent engineering for the iterative process of turning unpredictable LLM systems into reliable products: build, test, ship, observe, refine, repeat. That work covers how agents are built, evaluated and orchestrated. The design around the model matters there too: the MASEval study (March 2026) compared 3 frameworks and 3 models on 3 benchmarks and found that the choice of framework matters as much as the choice of model.

Example

Suppose a developer adds a booking form to a website. She describes the fields and validation rules and asks the coding agent to use red/green TDD. The agent writes failing tests, then the code, runs the tests and shows the changes. The developer reads the code, tries the form in a browser and only then opens a pull request, with notes on how she tested it.