The Agentic Engineering Playbook — Part 1
Why speed without structure is a trap, and how AI amplifies your engineering fundamentals.
Let’s be honest: AI coding tools are a little intoxicating right now. You type a prompt, hit Enter, and suddenly there’s a React component, a REST API, or half a feature sitting in front of you as if it appeared by magic. It’s fast. It’s fun. It’s also exactly why we need to get more serious about how we build with AI.
This is Part 1 of a five-part series by Alex Merced and Benedikt Stemmildt on what really changes when AI moves from helpful autocomplete to an active participant in software delivery. Part 1 is about the biggest mindset shift of all: AI doesn’t make engineering discipline less important. It makes it more important.
Beyond vibe coding
For most of software’s history, the fundamental bottleneck was the human translation of intent into syntax. We held grand architectures in our heads, but typing them out, debugging semicolons, satisfying borrow checkers and memorising standard libraries was a painstaking, manual craft.
Today that bottleneck has largely evaporated. A developer can describe a complex state machine or a functional REST API in natural language and get it back in seconds. But unlike a compiler, which translates one precise notation into another and produces the same output every time, these systems predict. They vary. The same request can produce different code twice. That difference is the whole reason engineering discipline matters more here, not less.
Early adopters embraced what Andrej Karpathy named vibe coding: intent first, syntax second, fast and loose and iterative. The developer acts as a head chef, barking orders at algorithmic sous-chefs. For small scripts and weekend projects it is genuinely liberating. Applied to production systems with real security, performance and scaling constraints, the same looseness becomes dangerous.
Left to their own devices, agents write code that appears functionally correct but is structurally disastrous. They tightly couple components, hallucinate dependencies, and introduce security vulnerabilities that pass review because the code reads fluently.
The thesis
Agentic software engineering is the pinnacle of traditional engineering rigour, not a break from it. The disciplines that make an agent productive are the ones you already know: testing, version control, modular design, continuous integration, tight feedback loops. None of it is new. What changes is who does the typing, and how much leverage each decision now carries.
Four eras of adoption
A second question is where the industry actually stands. The series maps it as four eras:
- Craft. AI is autocomplete. It speeds up the individual at the keyboard and nothing else changes. The large majority of companies still work here.
- Manufactory. The engineer steers the agent step by step and validates each step by hand. The leverage is real, but a human sits in the loop for every move. A growing minority of teams operate this way.
- Factory. The agent runs inside the loop, with deterministic orchestration between its steps, and the engineer’s job becomes designing the factory floor rather than walking it. Only a small fraction of teams have reached this.
The shift is from typing code to designing the systems that produce it, managing complexity, and optimising for learning. Generation is nearly free now. Judgment is the scarce resource.
