Beyond Vibe Coding: The Discipline of Vibe Engineering

Simon Willison recently drew a line in the sand with his post on ‘Vibe Engineering.’ He distinguished between two fundamentally different ways of working with AI: the careless, prompt-and-pray approach of ‘vibe coding,’ and the disciplined, professional practice he calls ‘vibe engineering.’

The Hacker News discussion that followed was predictably vibrant, debating everything from the term’s seriousness to whether AI offers a 10% or 1000% productivity boost. One commenter aptly compared aimless prompting to the superstitious rituals of Skinner’s pigeons, hoping for a random reward.

This conversation is critical because it forces us to move beyond the hype and define what it takes to use these tools professionally. Simon expertly identified what vibe engineering requires: robust testing, comprehensive documentation, good version control, and a ‘very weird form of management.’ But to truly move beyond vibe coding, we have to answer the billion-dollar question: how do you actually do it?

The answer is that the ‘vibe’ is a misnomer. The feeling of a successful, intuitive collaboration with an AI agent isn’t magic. It’s the result of a rigorous, repeatable discipline. To practice Vibe Engineering, you must master Context Engineering.

From Superstitious Pigeons to Scientific Process

Without a systematic approach, using AI agents feels exactly like the pigeon experiment. You tweak a prompt here, add a file there, and hope the agent’s behavior changes for the better. This is the essence of vibe coding, and it’s not engineering; it’s superstition.

Context engineering, a term I first explored after seeing Tobi Lutke frame it as ‘the art of providing all the context for the task to be plausibly solvable by the LLM,’ is the science that replaces the superstition. It’s the craft of systematically designing, packaging, and delivering the precise information an agent needs to succeed.

When you master context engineering, you are no longer a pigeon pecking at a button. You are the scientist designing the experiment, controlling the variables, and ensuring a predictable outcome. Simon’s list of prerequisites for vibe engineering aren’t just good practices; they are the essential inputs for this scientific process.

The ‘How’: A Codified Workflow for Context

If moving beyond vibe coding is the goal, Context Engineering is the road map. It’s not just about writing a better prompt; it’s about a two-stage process where one agent prepares the battlefield for another. I call this the ‘Scout and Execute’ pattern.

A ‘Scout’ agent’s sole job is to survey the codebase and curate the perfect context. It doesn’t write a single line of implementation. Its only deliverable is a high-fidelity briefing for the ‘Execute’ agent. This codifies Simon’s ‘weird form of management’ into a repeatable workflow.

Consider the directives for a Scout agent:

• Directory-first discovery: Map the architecture by analyzing directories before diving into files. This is like understanding a city’s layout before visiting individual buildings.
• Inclusive selection: The scout’s goal is to create a complete ‘universe’ for the next model. It prioritizes relevance over strict token limits, understanding that missing context is more costly than a few extra tokens.
• Surgical reads: Use code structure analysis (codemaps) to identify key symbols and relationships, only reading specific lines of code when absolutely necessary.
• The Handoff: The final output is a curated list of files and a concise, clarifying prompt that distills all its findings, including any open questions or architectural decisions that need to be made.

This isn’t a vague instruction; it’s a precise operational sequence. The Scout agent systematically explores, analyzes, and packages the environment. The Execute agent receives a perfect, context-rich request and can perform its task with a much higher probability of success. This is the discipline that separates engineering from mere vibing.

Building an Agent-Ready Environment

This structured workflow is incredibly powerful, but it relies on an environment that is legible to machines. This is where the principles of Agentic Experience (AX) become paramount. You must build systems for your new, infinitely scalable machine workforce.

An AX-first mindset means every part of your system is evaluated for its machine-friendliness.

• Are your CLI tools chatty and verbose, or do they offer structured, predictable output? Building Agent-Friendly CLI Tools is no longer a luxury.
• Is your codebase a maze of implicit dependencies, or does it follow the principles of Agent-Friendly Go, with explicit data flow and clear interfaces?
• Does an agent need complex, abstract protocols to interact with your system, or can it use the most powerful and direct interface ever created: code itself? As I’ve argued before, when it comes to Agentic Tools, Code Is All You Need.

These aren’t just ‘good automation’ practices. They are foundational architectural decisions. A clean, agent-friendly environment makes the Scout’s job easier, which in turn leads to better outcomes from the Execute agent. It’s a virtuous cycle.

Closing the Feedback Loop

The final piece of this disciplined approach is the feedback loop. The ‘Scout and Execute’ pattern gives the agent context to act, but it also needs context on the consequences of its actions.

This is where tools like Context (ctx) become essential. A good manager wouldn’t send a junior developer on a task with an unlimited budget and no check-ins. Likewise, ctx gives an agent visibility into its own resource consumption, turning a blind execution into an informed action. It allows the agent to ask, ‘Will running git diff on this repo consume 100 tokens or 100,000?’ This isn’t just about saving money; it’s about giving the agent a crucial piece of operational data to make smarter decisions.

Unlocking the 1000% Productivity Gain

The Hacker News threads were filled with debates on whether AI provides a mere 10% boost or a game-changing 1000% one. The truth is, both are correct.

If you are ‘vibe coding’—treating AI as a better autocomplete—you’ll get a 10% gain. You’ll type less, but you won’t fundamentally change how you work.

The 1000% gain is unlocked when you practice vibe engineering, powered by a mastery of context. An expert developer can enter a new codebase, direct a Scout agent to rapidly build a context bundle about its architecture and patterns, and then hand that bundle to an Execute agent with a clear objective. The agent, armed with perfect context, can then perform complex tasks that would have taken the developer days of manual exploration.

You’re no longer just coding. You’re architecting understanding. That’s the force multiplier.

Conclusion: The Discipline Behind the Vibe

‘Vibe Engineering’ is a brilliant, provocative term because it gets us talking. But its real value is in forcing us to define what separates professional, scalable AI development from amateurism. Moving beyond vibe coding isn’t about better prompts; it’s about better process.

That process is built on discipline. The discipline to systematically scout the terrain before acting. The discipline to design for agents, not just humans. The discipline to build feedback loops.

This is the substance that makes Vibe Engineering work. Context Engineering is the set of practices that turns a powerful but unpredictable technology into a reliable engineering partner. It’s how you avoid accumulating ‘AI-slop’ and instead build a system where AI’s contribution elevates your entire codebase.

I’ve outlined the pillars here, but the rabbit hole goes deeper. Context engineering isn’t just about providing static information; it’s about building systems where prompts are dynamically generated from live state.

In a future post, I’ll explore how Context Engineering allows human developers to go beyond Vibe Engineering, moving humanity beyond the prompt into the next layer of truly adaptive agentic systems.