We all use LLMs to make code, but there are at least two distinct modes of working with them. Both are powerful, but conflating them is dangerous. It leads to burnout, loss of agency, security breaches, and disastrous outages. Instead, we want to enable better ideas, executed faster, at higher quality.

Why this matters

  • Both modes have real value, but only when used deliberately and in the right context.
  • Vibecoding is extremely helpful, but invites overconfidence. It produces code that’s brittle.
  • Agentic engineering is about being confidently accountable for the software while using LLMs to accelerate output.

The golden rule: don’t merge code to production that you couldn’t explain to someone else.

What is vibecoding?

Vibecoding means operating by feel and taste, ignoring the code completely. It allows you to rapidly iterate on the output. In vibecoding, the code is an ephemeral, malleable, disposable backdrop. Embrace the exponentials, let Claude take the wheel, and sculpt towards behaviour you like and ideas you want to validate.

Vibecoding is for low-stakes, high-velocity exploration, so good vibecoding projects enhance your feedback loops.

Use vibecoding when:

  • You’re exploring ideas, UI sketches, or small tools.
  • You can verify the output without looking at the code.
  • You want to learn the LLM’s capabilities and build intuition for what works.
  • Speed-to-insight matters most.

What is agentic engineering?

Agentic engineering is a series of disciplines and systems for engineers to amplify their expertise by overseeing agents carrying work from spec to production under explicit constraints, evaluation, and review.

Agentic engineering relies on robust, repeatable environments in which agents operate: specs, tests, evals, tools, data, context, and detailed human review. The output is readable, maintainable code that works and that you can explain, delivered in small human-readable PRs backed by your own meticulous review.

Use agentic engineering when:

  • The artefact must be reliable, explainable, and maintainable.
  • You can’t get away with vibes because of safety, compliance, or long-lived systems.
  • The code will be reviewed, deployed, and built upon by others (human and agent).

Good agentic engineering gets easier over time when you practise compound engineering: every bug, test, and insight is captured so that each feature makes the next feature easier to build via better agent knowledge and tooling. This is the flywheel that separates teams who use LLMs well from teams who just use them a lot.

The practical workflow

Start with vibecoding to figure out what to do, then either:

  • (A) Burn it: set the acceptance criteria/vision, then throw the code away and craft it from scratch, or
  • (B) Graduate it: manually extract the parts that matter into an agentic workflow with tests, evals, and proper review. Read every line of code.

The key is being clear about which mode you’re in and making the transition explicit.

I think of vibe coding using its original definition of coding where you pay no attention to the code at all, which today is often associated with non-programmers using LLMs to write code. Agentic Engineering represents the other end of the scale: professional software engineers using coding agents to improve and accelerate their work by amplifying their existing expertise. The job of a software developer is not (just) to churn out code and features. We need to create code that demonstrably works, and can be understood by other humans (and machines), and that will support continued development in the future. We need to consider performance, accessibility, security, maintainability, cost efficiency. Software engineering is all about trade-offs—our job is to pick from dozens of potential solutions by balancing all manner of requirements, both explicit and implied.

— Simon Willison, Agentic Engineering Patterns

Thanks to my colleagues at TORTUS for feedback on early drafts of this post.