Formalizing vibe coding into Agentic Engineering. Explore Andrej Karpathy
From Vibe Coding to a Named Discipline
"Vibe coding" describes the loose, improvisational way many people now build with large language models: you describe what you want in plain language, accept what the model produces, and nudge it until the result feels right. It is fast and forgiving, but it is also unstructured. There is no shared vocabulary for what you did, no repeatable process, and little that survives past the session. Andrej Karpathy's framing of Software 3.0 takes that instinct seriously and asks what it looks like when you treat it as an actual engineering practice rather than a party trick.
The core shift is in what you write. In earlier eras, the artifact was source code you compiled or interpreted directly. In Software 3.0, the primary artifact is the prompt and the surrounding context you hand to a model that generates behavior. Agentic Engineering is the name for doing that deliberately: specifying intent precisely, giving the model tools and feedback, and holding the output to the same standards you would apply to code a person wrote.
What Makes It "Agentic"
The word agentic points at the difference between asking for a snippet and delegating a task. An agent does not just emit text; it takes actions, observes results, and iterates toward a goal. That changes the engineer's job from typing every line to designing the loop the agent runs inside — what it can do, what it can see, and how you know when it is done.
In practice, the work concentrates on a few recurring concerns:
- Specification. Turning a vague desire into an unambiguous description of the target, including the cases where things go wrong.
- Context. Deciding what information the model actually needs in front of it, and leaving out what only adds noise.
- Verification. Defining how you check the output — tests, examples, or a human review — so "it looked right" is not the only signal.
- Iteration. Feeding failures back in a form the agent can act on, rather than restarting from scratch each time.
Why Formalizing It Matters
The reason to formalize vibe coding is the same reason any craft benefits from method: it makes results reproducible and reviewable by someone other than the author. When the process is implicit, two people using the same tools get wildly different outcomes, and neither can explain why. When the steps are named, you can teach them, critique them, and improve them. A weak specification stops being a mystery and becomes a fixable input.
It also clarifies where human judgment still carries the weight. The model can generate quickly, but deciding what to build, what "correct" means, and whether the result is trustworthy remains the engineer's responsibility. Agentic Engineering does not remove that judgment — it moves it upstream, into the framing and the checks.
How to Start Practicing It
You do not need a new toolchain to begin. Take one task you would normally vibe-code and write down the goal, the constraints, and how you will verify success before you prompt anything. Let the agent produce a first pass, then judge it against those criteria instead of your gut. Keep the prompts and context that worked, so the next similar task starts from something better than a blank slate.
Done consistently, this turns scattered sessions into a growing set of reusable patterns. That accumulation — clearer specs, sharper context, honest verification — is what separates Agentic Engineering from vibe coding, and it is the practical substance behind the Software 3.0 idea.