Agentic Engineering: A Professional Methodology Beyond “Vibe Coding”
The concept of “Agentic Engineering,” systematically articulated by renowned developer Simon Willison since February 2024, provides a clear set of guidelines for professional software engineers in the age of AI. Its core objective is to guide engineers on how to professionally use “Coding Agents”—such as those based on Large Language Models (LLMs) like Claude or Codex—that can write and execute code to produce reliable and maintainable software.
Agentic Engineering’s key distinction lies in its professional focus. It stands in clear contrast to “Vibe Coding,” a term popularized by Andrej Karpathy, which describes a more casual, non-programmer-oriented approach for rapid prototyping, often without rigorous review. Within the Agentic Engineering framework, the core feature of a coding agent is its ability to “execute code.” An agent is essentially a system that calls tools in a loop to achieve a goal. For a coding agent, the ability to execute code and iterate based on the results is the fundamental source of its value. This allows the agent to iterate from text output that “might not run” to software that “definitively works.”
In this paradigm, the role of the human engineer is not diminished but rather abstracted upwards, focusing on higher-value work:
- Defining Problems and Goals: Deciding what code needs to be written and making trade-offs among various solutions.
- Providing Tools and Specifications: Supplying the agent with the necessary toolset and sufficiently detailed requirements to complete the task.
- Validating Results: Rigorously reviewing and testing the agent’s output to ensure it is robust and trustworthy.
- Systematic Improvement: Solidifying successes and failures into better prompts or control harnesses, enabling continuous learning and evolution of the entire development system.
The Disruption of Code Cost and the Adherence to Quality Standards
Agentic Engineering is built on a core premise: the cost of writing code is approaching zero, but the cost of writing high-quality code remains high.
For decades, software engineering practices have been built on the assumption that “code is expensive.” This has led to extensive upfront design, estimation, and scheduling at a macro level. At a micro level, engineers’ decisions on whether to refactor, write tests, add documentation, or develop debugging tools have been constantly constrained by time costs.
Coding agents completely shatter this constraint. Engineers can now run multiple agents in parallel to handle feature implementation, code refactoring, test writing, and documentation generation simultaneously. However, the standards for “good code” have not changed. They still include clear requirements:
- Correctness: The code runs and has tests to prove it is correct.
- Effectiveness: It solves a real and correctly identified problem.
- Robustness: It properly handles error paths and edge cases, not just the “happy path.”
- Maintainability: The code is clean, easy to understand, and easy to modify.
- Documentation and Testing: It has sufficient test coverage and necessary documentation.
- Evolvability: The design allows for future changes, balancing the “You Ain’t Gonna Need It” (YAGNI) principle with system scalability.
- Non-Functional Requirements: It meets requirements for security, performance, observability, etc.
Therefore, engineers need to adopt a new mental model: when your intuition suggests an improvement (like a small refactor) is “not worth it,” try launching an asynchronous agent to attempt it. The worst-case scenario is wasting a small amount of computing resources, but more often than not, many quality improvements previously abandoned due to high costs are now feasible and worthwhile.
Five Core Principles: Building a Robust AI-Assisted Development Workflow
To systematically practice Agentic Engineering, Willison proposes five guiding principles:
- Define Boundaries, Clarify Roles: Insist that Agentic Engineering is a practice for professional engineers to amplify their capabilities, not to blindly accept AI output like in “Vibe Coding.” The human’s core responsibilities are to set goals, provide tools, validate results, and continuously optimize the prompt system.
- Embrace New Constraints, Change Old Habits: Recognize that code generation has become cheap. The old habit of skipping tests, documentation, or refactoring due to cost needs to be completely abandoned. Actively use agents to handle these tasks that are crucial for improving software quality.
- Accumulate Reusable Solutions: Consciously build a personal knowledge base of runnable, validated code snippets, scripts, or tools. When facing a new problem, providing the agent with one or two verified, similar examples (an effective form of few-shot prompting) can dramatically improve the accuracy and quality of its new solutions.
- Pursue Quality Improvement, Not Degradation: Use agents as a powerful tool to eliminate “code smells.” Issues like technical debt, confusing naming, or splitting large files—previously postponed because they were “simple but time-consuming”—can now be handled by background agents. The cost has become low enough to adopt a “zero-tolerance” policy for bad smells.
- Strictly Avoid Anti-Patterns, Prohibit Blind Commits: The most critical rule is: never commit any code that you have not personally reviewed and understood. A proper pull request generated with agent assistance must meet the following criteria: the engineer is confident it works, it is small and easy to review, it includes full context and a clear description, and it contains evidence of passing tests.
Key Practical Techniques: Collaborating Effectively with Coding Agents
Beyond the macro principles, Willison has also summarized several specific techniques for collaborating effectively with agents to improve development efficiency and code quality.
- Understand the Agent Mechanism: You don’t need to know the deep implementation details, but you should understand the basic working principles, such as: longer conversation contexts are more expensive; the model itself is stateless, and each call relies on the current context; the ability to execute code is the key differentiator from a standard chatbot.
- Use Git as a Safety Net: Treat Git as the agent’s “time machine” and “safety net.” Use natural language commands to have the agent perform
git bisect to find a bug-introducing commit, recover lost code, or handle complex commit history cleanup, thereby enabling safe experimentation.
- Strategically Use Subagents: For large, complex tasks that exceed a single agent’s context window, you can break them down and assign them to specialized subagents. For example, one subagent could explore the structure of an unfamiliar codebase and generate a summary, multiple subagents could modify different files in parallel, or you could use a dedicated testing/review agent. The principle is to split tasks to save context and enable parallelism, not for the sake of splitting.
- Establish a Multi-layered Testing Defense: Make testing a central part of collaborating with the agent. First, adopt a Test-Driven Development (TDD) approach: write a failing test first, then have the agent write code until the test passes. Second, run the full existing test suite before starting any new task. Finally, perform manual verification using tools like
curl, python -c, or Playwright, and require the agent to show the test commands and their actual results as “proof” in its output.
- Eliminate ‘Cognitive Debt’ with Code Walkthroughs: If the code generated by an agent becomes a “black box” that the engineer cannot understand, it accumulates “cognitive debt,” slowing down future development and maintenance. To avoid this, you can ask the agent to perform a “Linear Walkthrough,” explaining the code line-by-line, or engage in an “Interactive Explanation” to help the engineer quickly build a deep understanding of the code.
