Pillar Guide
Agentic Engineering
The discipline of shipping production work with AI agents that plan, build, review, and remember.
Agentic engineering is a structured methodology where AI agents execute multi-step workflows under human oversight, compounding institutional knowledge across every session. It is the discipline that replaced ad-hoc prompting once teams discovered that the bottleneck was never code generation -- it was planning, review, and memory.
The shift is measurable. The strongest practitioners now ship work through a repeatable lifecycle rather than a chat window, and the output compounds: Soleur itself has merged 420+ pull requests through this exact pipeline. This page defines the term, traces its lineage from vibe coding, breaks down the five properties of an agent and the five-stage workflow, contrasts it with the alternatives, and maps where it works and where it breaks.
For the comparison that put the term on the map, read Vibe Coding vs Agentic Engineering. For the broader business category this engineering discipline powers, see Company-as-a-Service.
The Lineage: From Vibe Coding to Agentic Engineering
The vocabulary arrived in stages. Andrej Karpathy coined "vibe coding" in February 2025 to describe a conversational style where you "fully give in to the vibes" and let the model generate code on demand. It was a breakthrough for prototypes and a liability for production -- the code worked until it did not, and nobody could say why.
Addy Osmani sharpened the distinction in The 70% Problem, observing that AI gets you most of the way fast but the last 30% -- the integration, the edge cases, the maintainability -- is where unstructured AI work falls apart. The academic framing followed: arXiv 2505.19443 formalized the split between vibe-driven and agentic approaches to software work, distinguishing exploratory generation from goal-directed, verifiable execution.
Agentic engineering is the answer to the 70% problem. It keeps the speed of AI generation and adds the structure that makes the output shippable: a plan before code, a review after it, and a memory that carries the lesson forward.
The Five Properties of an Agent
"Agent" is the most abused word in the field. A useful agent -- as distinct from a prompt wrapper -- has five properties, and the discipline of agentic engineering is built on all five.
- Goal-oriented. It accepts an objective and decomposes it, rather than completing a single instruction.
- Tool-using. It reads files, runs commands, and calls services -- often via the Model Context Protocol.
- Memory-carrying. It persists decisions and patterns across sessions in a knowledge base.
- Verifiable. It produces inspectable artifacts -- diffs, plans, test results -- not opaque answers.
- Correctable. Human feedback changes future behavior, not just the current turn.
LangChain's working definition of an agent centers the same idea: a system that uses an LLM to decide the control flow of an application. Anthropic's Building Effective Agents reaches the same conclusion from the practitioner side -- the systems that work are the ones that plan, act, and self-correct against a goal.
The Workflow: Brainstorm, Plan, Implement, Review, Compound
Agentic engineering is not a single prompt. It is a lifecycle with five stages, each with a human checkpoint. This is the pipeline Soleur runs on its own codebase every day.
- Brainstorm. Explore the problem space and surface the approaches before committing to one. Ambiguity gets resolved here, not in code review.
- Plan. Write the plan to a file -- scope, steps, files touched, tests. The plan is the contract the agent implements against.
- Implement. The agent writes the code, runs the tests, and iterates until the plan's acceptance criteria pass.
- Review. A separate agent (and a human) reviews the diff for correctness, security, and simplicity before merge.
- Compound. The lesson -- a new pattern, a fixed gap, a convention -- is written back into the knowledge base so the next project starts ahead of this one.
The compound stage is what separates agentic engineering from faster typing. Without it, every project re-learns the same lessons. With it, the system's effective expertise grows with every merge.
Agentic Engineering vs Vibe Coding vs AI-Assisted Development
| Dimension | Vibe Coding | AI-Assisted Development | Agentic Engineering |
|---|---|---|---|
| Unit of work | A prompt | An autocomplete | A planned, reviewed task |
| Human role | Vibe-checker | Driver | Decision-maker + reviewer |
| Memory | None | Editor context only | Compounding knowledge base |
| Verification | Run it and see | Developer reads each line | Tests plus agent + human review |
| Best for | Prototypes, weekend hacks | Faster individual coding | Production software, recurring processes |
Why Compounding Knowledge Is the Whole Point
The stage that separates agentic engineering from "AI that types faster" is compound. In an unstructured workflow, every project re-learns the same lessons: the same convention gets re-explained, the same edge case gets re-discovered, the same review comment gets written for the tenth time. Effort does not accumulate. The team runs in place at high speed.
Agentic engineering treats every solved problem as an asset. A new pattern, a fixed gap, a hard-won convention -- each gets written back into the knowledge base so the next project inherits it for free. Over hundreds of merges this produces a compounding curve: the system's effective expertise grows, the cost of each new task falls, and the quality bar rises rather than drifts. Soleur's 420-plus merged pull requests were not 420 independent efforts; each one started from the accumulated lessons of the ones before it. That is the moat -- not the model, but the memory around it. Read more in Knowledge Compounding in AI Development.
The Human Checkpoints That Keep It Honest
Agentic engineering is not autonomous engineering. Every stage has a point where a human steers, and removing those points is the fastest way to turn the discipline back into vibe coding. The plan is approved before implementation begins, so the agent builds against an agreed contract rather than an assumption. The diff is reviewed before merge, so correctness and security are verified by judgment, not hope. And the compounded lesson is one a human signed off on, so the knowledge base accrues truth rather than noise.
The founder's role is decision-maker and reviewer, not typist and not absentee. This is the human-in-the-loop pattern, and it is what lets a solo founder trust agents with production work: not blind faith, but verifiable artifacts at every checkpoint.
Where It Works and Where It Breaks
Agentic engineering shines on production software and recurring business processes -- anything where correctness matters, the work repeats, and a compounding memory pays off. It is overkill for a weekend hack or a throwaway script, where vibe coding's speed wins and the ceremony of a plan-and-review loop is pure overhead.
It also breaks when the human abdicates the review checkpoint. The discipline depends on the founder staying the decision-maker -- the agent executes, the human judges. Remove the judgment and you are back to vibe coding with extra steps.
The Tooling Landscape in 2026
The tools sit on a spectrum from generation to orchestration. Cursor and GitHub Copilot lead AI-assisted development inside the editor. Claude Code moved the unit of work from the line to the task. Soleur extends that further -- the full brainstorm, plan, implement, review, compound lifecycle as a reference architecture, with 67 agents and 83 skills wired into a shared knowledge base. The disambiguation that trips up most teams -- plugin versus skill versus MCP -- is covered in this reference and the Claude Code plugins pillar.
Get Started with Agentic Engineering
The fastest way to understand agentic engineering is to run it. Install Soleur and ship one real task through the full lifecycle -- a plan, an implementation, a review, and a compounded lesson.
claude plugin install soleurFrequently Asked Questions
What is agentic engineering?
Agentic engineering is a structured methodology where AI agents execute multi-step workflows under human oversight, compounding institutional knowledge across every session. It replaced ad-hoc prompting once teams found the bottleneck was planning, review, and memory rather than code generation. The work runs through a repeatable lifecycle and the output compounds with every merge.
How is agentic engineering different from vibe coding?
Vibe coding is conversational generation where you accept whatever the model produces and run it to see if it works, which suits prototypes. Agentic engineering keeps the speed of generation but adds a plan before the code, tests and review after it, and a memory that carries the lesson forward. The difference is structure and verification, which is what makes the output shippable to production.
What are the five properties of an AI agent?
A useful agent is goal-oriented, tool-using, memory-carrying, verifiable, and correctable. It accepts an objective and decomposes it, reaches outside itself to read files and call services, persists decisions across sessions, produces inspectable artifacts like diffs and test results, and changes its future behavior when a human corrects it. A prompt wrapper that lacks these is not an agent.
What is the agentic engineering workflow?
The workflow is a five-stage lifecycle with human checkpoints: brainstorm to explore approaches, plan to write the scope and steps to a file, implement to write code and pass tests, review to check the diff for correctness and security before merge, and compound to write the lesson back into the knowledge base. The compound stage is what makes the system get faster with use.
When should I not use agentic engineering?
Skip it for weekend hacks and throwaway scripts where vibe coding is faster and the plan-and-review loop is pure overhead. It is built for production software and recurring business processes where correctness matters and a compounding memory pays off. It also breaks if the human abandons the review checkpoint, because the discipline depends on the founder staying the decision-maker.