Agentic engineering, 2026
Agents write the code. The flow decides if it ships.
Not one big prompt — a system: clear intent, engineered context, a plan with a human gate, an orchestrator with sub-agents, real tools, a verification loop, an independent review and a feedback path from production. Here it is, animated.
- intent
- context
- plan · gate
- agents
- tools
- verify
- review
- ship · learn
Intent, not instructions
The best agents are not told how. They are told what, why, the constraints, and what “done” means. A good agent asks before it assumes.
Outcome of this step: a short spec with acceptance criteria that both sides can point at.
Context is engineered, not pasted
The context window is the agent’s working memory — and a budget. Rules live in files, memory persists between sessions, the repo is mapped, tools are declared. When the window fills up, it gets compacted, not lost.
Rule of thumb: everything the agent needs to know twice belongs in a file it reads automatically.
A plan, then a human gate
Before a single file changes, the agent explores read-only and proposes a plan: files, changes, risks, how it will verify. A human reads it and explicitly approves. Cheap to reject a plan; expensive to reject a thousand lines.
The gate is the single most important control in the whole flow.
An orchestrator and its sub-agents
One agent keeps the big picture. It splits work into independent pieces and hands them to sub-agents with their own, isolated context: explore, implement, test, review. They run in parallel; results come back small and structured; the orchestrator merges.
Parallelism where tasks are independent — never where they share state.
Tools instead of guesses
An agent that can only talk will hallucinate. An agent with tools reads the file, runs the tests, opens the browser, queries the database — and gets typed results back. Open protocols like MCP make every system a tool.
The rule: never assert what a tool can check.
The verification loop
Write, test, fix, test again — autonomously, until green. Unit tests for logic, end-to-end tests for flows, a real browser for what a user sees. The agent shows the evidence; “it should work” is not a result.
If something cannot be verified, the agent says so instead of guessing.
A second agent reviews
The agent that wrote the code is the worst judge of it. An independent reviewer with fresh context reads the diff against the spec and the codebase conventions: correctness, security, simplicity. Evals measure quality over time, not just once.
Comments are addressed by the author agent; the human sees a clean, argued diff.
Ship small, watch, feed it back
Small, reversible changes go through the same pipeline every time: build, test, deploy, observe. Logs, errors and evals flow back into the backlog — and into the agent’s memory — so the next iteration starts smarter.
The loop closes here. Then it starts again, one intent at a time.
Six principles that hold it together
- Humans own intent and the gate.Agents propose; people decide what ships and why.
- Small, reversible steps.One plan, one change, one commit. Easy to review, easy to undo.
- Verify in reality.Tests, browsers, staging — not the model’s confidence.
- Context lives in files.Rules, memory and tool definitions are versioned with the code.
- Parallelize independent work only.Sub-agents with isolated context; a single owner of shared state.
- Measure quality, not just speed.Evals and production signals decide whether the flow is working.
Want this flow in your team?
Rules, tooling, agents and the verification loop — set up and proven on real products. Let’s talk.