Agentic Engineering: Better Vibes

Vibe coding (Adrej Karpathy’s term which means using AI to generate software via natural language prompts) is a powerful, high-risk tool that is neither solely “bad” nor “good.”

As Google points out, while it offers rapid prototyping and speeds up learning for beginners, it frequently produces unmaintainable, insecure, and “brittle” code, making it risky for production systems and a contentious trend in 2026.

However there is a structured discipline which, though it produces close to the same velocity in terms of lines of code generated, doesn’t suffer drawbacks.

Agentic Engineering

Make no mistake. There are cases where that “move fast and break things” mentality which vibe coding embodies can absolutely be the right way to go.

When companies are wanting to see quick iterations as prototypes before they begin to build out their apps, vibe coding can rapidly reveal where their ideas need improvement, and even better, whether their app needs to exist at all.

This is invaluable. However, ideally these prototypes must then be scrutinized by those whose experience level will let them anchor the new design in a well-structured, easily-maintainable codebase.

Karpathy’s new term for this is “agentic engineering.” 

Specificity Matters

Agentic engineering involves the careful direction of agents by explicitly defining the desired output up front, orchestrating agents to create one feature at a time, and reviewing and testing before moving on.

This new methodology can be taken to the next level by using skills to grill the engineer on specific design decisions which are then converted into a Project Requirements Document (PRD) and user stories, which are then converted into vertical tasks (whose blocking relationships are identified), which can then be orchestrated with a Kanban.

Some engineers will want to direct the AI agents to employ Test Driven Development (TDD) as they write each piece of code, although it can be difficult to force the AI to refactor its own code.

AI Centered Dev Lifecycle

Comparisons to different development methodologies (such as waterfall and agile) are inevitable, but here is a potential software development outline which I feel has real potential as far as generating maintainable code (credit due to Matt Pocock):

1. Idea: Come up with an idea for an app or refactor an app.
2. Research (optional): If execution involves difficult expository phases, create a research.md asset to store them.
3. Prototype (optional): Hash out ideas quickly in code  in order to get early feedback. In my estimation, this is where “vibe coding” comes into play, but it is only for the purposes of creating assets which can later be used in the implementation. The prototype itself should be considered a “throw away.”
4. PRD: Create a markdown file which describes the destination, with user stories and implementation notes.
5. Kanban: Turn the PRD into individual tickets with blocking relationships.
6. Execution: In a loop, run a coding agent (or agents if non-blocking) to execute all of the tickets on the Kanban board.
7. QA: Create a QA plan for a human to QA the completed work.

Steps 5, 6, and 7 would likely be repeated as the work is reviewed in order to hone in on the intended goal for the app.