Human understanding is the bottleneck of agentic engineering. Andrej Karpathy's latest conversation on “From Vibe Coding to Agentic Engineering” felt almost uncomfortably aligned with how we think about AdaL: AI coding is no longer mainly about generating more code. It is about preserving engineering quality while making the work easier for humans to understand, review, and ship.
Watch the full video here: Andrej Karpathy: From Vibe Coding to Agentic Engineering
Karpathy coined “vibe coding” and helped make the phrase unavoidable. But the most interesting part of this talk is that he moves beyond the vibe. His distinction is the same one AdaL is built around: vibe coding raises the floor, while agentic engineering protects the quality bar.
That is the real production frontier. Teams are not blocked because they cannot generate enough code. They are blocked because generated work still has to be understood, reviewed, trusted, and shipped without weakening the product.
That is exactly where AdaL is focused.
The core idea: vibe coding raises the floor
Karpathy's framing is generous to vibe coding. He does not dismiss it.
He says vibe coding is about raising the floor of what everyone can do in software. That is real. A non-engineer can prototype an app. A founder can test ten product ideas. A student can build something that would have required a team a few years ago.
This is a huge shift.
But raising the floor is not the same as raising the ceiling.
A prototype can tolerate messy abstractions, duplicated logic, weak tests, and occasional weirdness. A production system cannot.
Once software touches users, money, auth, enterprise data, infrastructure, or compliance, the standard changes.
The question becomes:
- Is the architecture sane?
- Are the abstractions maintainable?
- Are edge cases handled?
- Are secrets safe?
- Are permissions scoped?
- Are tests meaningful?
- Can a teammate review this diff without reading a novel?
- Can we explain why the agent made this change?
That is not vibe coding.
That is engineering.
Agentic engineering is about keeping the quality bar
Karpathy describes agentic engineering as the discipline of coordinating powerful but jagged agents so we can go faster without sacrificing quality.
That is the right phrase: discipline.
The agent is not a magic senior engineer. It is more like a very fast intern with incredible recall, inconsistent judgment, and no real ownership of consequences.
It can fill in APIs you forgot. It can write boilerplate. It can refactor a large surface area. It can generate tests. It can inspect files. It can explain code.
But it can also make a design mistake that looks fine at first glance.
In the talk, Karpathy gives a concrete example from one of his projects: the agent tried to associate Stripe purchases with Google accounts by matching email addresses. It worked until you remember that people can use different emails for Stripe and Google.
That is exactly the kind of bug agents create.
Not obviously syntactically wrong. Not necessarily caught by the first happy-path test. But architecturally wrong.
This is why production AI coding is not about removing humans from the loop. It is about changing what humans do in the loop.
Humans should spend less time remembering whether an API uses dim, axis, keepdim, or keepdims, and more time asking whether the system feels right: whether the design is coherent, whether the abstraction has taste, whether the architecture will survive the next feature, and whether the change is safe enough for someone else to trust.
That is the work AdaL is built around. Not just producing code faster, but making the work easier to understand, easier to review, and easier to ship with confidence.
The real bottleneck: review velocity
As coding agents get better, code generation becomes abundant.
That creates a new bottleneck: review velocity.
Review velocity means how fast a team can understand, validate, and ship changes without lowering the quality bar.
If an agent can generate ten pull requests a day, but the team can only thoughtfully review two, then the bottleneck is not coding. The bottleneck is review.
This is where many teams feel the pain:
- the diff is too large
- the intent is unclear
- tests are missing or shallow
- the agent changed unrelated files
- the reviewer lacks context
- the plan was never agreed on
- the PR summary is not enough
- risk is not called out
- the human has to rediscover everything from scratch
So people either slow down or rubber-stamp.
Both are bad.
The future of coding agents is not “generate more code.”
It is code that is easier to review, easier to trust, and easier to ship.
This connects to another point Karpathy made near the end of the talk. He cited a line he keeps returning to:
“You can outsource your thinking, but you can't outsource your understanding.”
Then he explained why that matters for agent work:
“I'm still part of the system… information still has to make it into my brain. I feel like I'm becoming a bottleneck of just even knowing what are we trying to build, why is it worth doing, how do I direct my agents, and so on.”
That is review velocity in a deeper sense. The bottleneck is not just clicking approve on a pull request. The bottleneck is whether the human can understand the work well enough to direct the agent, judge the design, and trust the outcome.
As Karpathy put it later, these tools should “enhance understanding,” because “you can't be a good director” if you do not understand what is happening.
That is why AdaL treats planning, tool use, review, and validation as first-class parts of the workflow.
Plan mode should not be complicated
One of the most useful parts of Karpathy's talk is his skepticism about “plan mode” as a product gimmick.
Planning matters. But the value is not that a product has a fancy mode switch called Plan Mode.
The value is engineering discipline:
- Do you understand the codebase before changing it?
- Did you identify the smallest safe change?
- Did you explain the trade-offs?
- Did you consider failure modes?
- Did the human agree with the direction?
- Are you preserving the design taste of the existing system?
A good plan mode should not feel like ceremony.
It should enforce a simple rule:
Do not modify source code until the plan is clear.
That is how AdaL thinks about planning.
AdaL's plan mode is intentionally simple. It is not magic. It is not a giant workflow diagram. It is a constraint: the agent can reason, inspect, and propose, but it cannot change source code until the plan is accepted.
That constraint matters because most bad AI coding outcomes do not start with a bad line of code.
They start with the agent confidently making the wrong change.
Planning is how you prevent the wrong change before it exists.
This is why AdaL feels aligned with Karpathy
Karpathy's framing feels 100% aligned with what we believe: the future of coding agents is not about flooding teams with more code. It is about raising quality while lowering the cost of understanding.
1. AdaL Code is imprinted with strong engineering practice. It pushes agents to plan before changing code, keep edits scoped, preserve the taste of the existing system, run validation, and explain what changed. In interviews, we have seen candidates solve engineering problems much better with AdaL than with Cursor.
2. Transparency is the real speedup. The win is not how quickly an agent can produce code. The win is how quickly a human developer can understand what the agent is doing, decide whether the work is good, and ship it with confidence. AdaL does this by showing every single step the agent is taking — not hiding the work behind vague summaries like “searched 3 files,” “read 10 files,” or “a subagent found this.”
3. AdaL Review lowers the barrier to understanding. We are building an agentic IDE with code review built in. AdaL Code raises the bar for agent quality. AdaL Review makes the agent's work easier for developers to inspect, understand, and trust.
If you are interested in early access, comment with your LinkedIn link and we will reach out.
Vibe coding is incredible for exploration.
Agentic engineering is how we ship.