You've likely heard of AI coding assistants, but 'Agentic Engineering' takes this a step further. ' Think of powerful AI tools like Claude Code or OpenAI Codex. The key difference here is that these aren't just fancy autocomplete tools. ude Code or OpenAI Codex. The key difference here is that these aren't just fancy autocomplete tools. What makes them 'agents' is their ability to not only *generate* code but also *execute* it. This is a game-changer. They can test their own work, see if it runs, and iterate on it without needing a human to guide every single step. It's about moving from a turn-by-turn conversation to giving the AI a goal and letting it work more independently to achieve it. This isn't about replacing developers. Quite the opposite. Agentic Engineering is a discipline for professional software engineers who use these powerful agents to amplify their own expertise. It’s a tool to help seasoned pros work faster and more efficiently, essentially supercharging their existing skills to deliver more value.
The Core Challenge: When Code Becomes Cheap
One of the fundamental shifts that comes with Agentic Engineering is a change in the economics of software development. As author and developer Simon Willison puts it in one of his documented patterns, 'Writing code is cheap now.' The central challenge this presents is that the cost to produce an initial, working version of some code has dropped to almost nothing. An agent can churn out a first draft in seconds. This means the value is no longer in simply producing lines of code. The real work—and the real skill—now lies in defining the problem correctly, guiding the agent, validating its output, and integrating it into a larger, reliable system. The central challenge of agentic engineering: the cost to churn out initial working code has dropped to almost nothing.
Finding a Path Forward with Design Patterns
With any new and powerful methodology, the question becomes: how do we use it effectively and consistently? ' This initiative aims to create a collection of best practices and reusable solutions to common problems faced when working with coding agents. lection of best practices and reusable solutions to common problems faced when working with coding agents. ' Just as that book gave developers a shared vocabulary and set of solutions for object-oriented programming, this new collection of patterns aims to do the same for the age of AI-powered development. ry and set of solutions for object-oriented programming, this new collection of patterns aims to do the same for the age of AI-powered development.
A Key Pattern: Test-Driven Development (TDD)
So what does one of these patterns look like in practice? A perfect example is applying a tried-and-true software development practice: Test-Driven Development (TDD). This method provides the structure needed to effectively manage a coding agent. The pattern, sometimes called 'Red/green TDD,' involves writing tests *before* you ask the agent to write the code. You first write a test that fails (the 'Red' phase), then you instruct the coding agent to write the code that makes the test pass (the 'Green' phase). This simple process has a profound impact. Why does this work so well? Because it provides clear, unambiguous success criteria for the AI. ' The result is that the agent tends to write more succinct and reliable code with much less back-and-forth and minimal extra prompting. more succinct and reliable code with much less back-and-forth and minimal extra prompting. A flowchart diagram illustrating the Red-Green-Refactor cycle of Test-Driven Development (TDD). It starts with 'Write a Failing Test (Red)', moves to 'Write Code to Pass Test (Green)', then to 'Refactor Code', and loops back.
The Most Important Component: The Human Expert
It's crucial to remember that Agentic Engineering is a partnership. The goal is to amplify human expertise, not render it obsolete. The professional engineer is the supervisor, the architect, and the final quality check. This human-centric approach is vital. For instance, Simon Willison, whose work informs these patterns, has a strong personal policy against publishing AI-generated text under his own name. While he uses AI extensively for tasks like proofreading or fleshing out code examples, the core ideas and the final written words remain his own. This distinction is key: the AI is a tool, not the author.
A Real-World Example: Building with an Agent
To see how effective this can be, look no further than the project to document these patterns itself. The entire software feature for publishing the 'guide' on Willison's website—including the database models and the associated web views—was built using this approach. ' This demonstrates that complex, real-world features can be successfully developed by an engineer guiding a powerful coding agent, a powerful proof point for the methodology. developed by an engineer guiding a powerful coding agent, a powerful proof point for the methodology. - **Agentic Engineering uses AI 'agents' that can write, execute, and test code independently, moving beyond simple code completion. - The primary challenge is adapting to a world where the initial draft of code is nearly free, shifting focus to problem definition, guidance, and validation. - Adopting established software practices like Test-Driven Development (TDD) provides clear goals for AI agents, resulting in more reliable and succinct code. - The human engineer's role becomes even more critical, acting as an expert supervisor and architect to guide the AI and ensure quality.
What Exactly is Agentic Engineering?
You've likely heard of AI coding assistants, but 'Agentic Engineering' takes this a step further. ' Think of powerful AI tools like Claude Code or OpenAI Codex. The key difference here is that these aren't just fancy autocomplete tools. ude Code or OpenAI Codex. The key difference here is that these aren't just fancy autocomplete tools.
What makes them 'agents' is their ability to not only generate code but also execute it. This is a game-changer. They can test their own work, see if it runs, and iterate on it without needing a human to guide every single step. It's about moving from a turn-by-turn conversation to giving the AI a goal and letting it work more independently to achieve it.
This isn't about replacing developers.
Quite the opposite.
Agentic Engineering is a discipline for professional software engineers who use these powerful agents to amplify their own expertise.
It’s a tool to help seasoned pros work faster and more efficiently, essentially supercharging their existing skills to deliver more value.
The Core Challenge: When Code Becomes Cheap
One of the fundamental shifts that comes with Agentic Engineering is a change in the economics of software development. As author and developer Simon Willison puts it in one of his documented patterns, 'Writing code is cheap now.'
The central challenge this presents is that the cost to produce an initial, working version of some code has dropped to almost nothing. An agent can churn out a first draft in seconds. This means the value is no longer in simply producing lines of code. The real work—and the real skill—now lies in defining the problem correctly, guiding the agent, validating its output, and integrating it into a larger, reliable system.
The central challenge of agentic engineering: the cost to churn out initial working code has dropped to almost nothing.
Finding a Path Forward with Design Patterns
With any new and powerful methodology, the question becomes: how do we use it effectively and consistently? ' This initiative aims to create a collection of best practices and reusable solutions to common problems faced when working with coding agents. lection of best practices and reusable solutions to common problems faced when working with coding agents.
' Just as that book gave developers a shared vocabulary and set of solutions for object-oriented programming, this new collection of patterns aims to do the same for the age of AI-powered development. ry and set of solutions for object-oriented programming, this new collection of patterns aims to do the same for the age of AI-powered development.
A Key Pattern: Test-Driven Development (TDD)
So what does one of these patterns look like in practice? A perfect example is applying a tried-and-true software development practice: Test-Driven Development (TDD). This method provides the structure needed to effectively manage a coding agent.
The pattern, sometimes called 'Red/green TDD,' involves writing tests before you ask the agent to write the code. You first write a test that fails (the 'Red' phase), then you instruct the coding agent to write the code that makes the test pass (the 'Green' phase). This simple process has a profound impact.
Why does this work so well? Because it provides clear, unambiguous success criteria for the AI. ' The result is that the agent tends to write more succinct and reliable code with much less back-and-forth and minimal extra prompting. more succinct and reliable code with much less back-and-forth and minimal extra prompting.
A flowchart diagram illustrating the Red-Green-Refactor cycle of Test-Driven Development (TDD). It starts with 'Write a Failing Test (Red)', moves to 'Write Code to Pass Test (Green)', then to 'Refactor Code', and loops back.
The Most Important Component: The Human Expert
It's crucial to remember that Agentic Engineering is a partnership. The goal is to amplify human expertise, not render it obsolete. The professional engineer is the supervisor, the architect, and the final quality check.
This human-centric approach is vital. For instance, Simon Willison, whose work informs these patterns, has a strong personal policy against publishing AI-generated text under his own name. While he uses AI extensively for tasks like proofreading or fleshing out code examples, the core ideas and the final written words remain his own. This distinction is key: the AI is a tool, not the author.
A Real-World Example: Building with an Agent
To see how effective this can be, look no further than the project to document these patterns itself. The entire software feature for publishing the 'guide' on Willison's website—including the database models and the associated web views—was built using this approach.
' This demonstrates that complex, real-world features can be successfully developed by an engineer guiding a powerful coding agent, a powerful proof point for the methodology. developed by an engineer guiding a powerful coding agent, a powerful proof point for the methodology.
**Agentic Engineering uses AI 'agents' that can write, execute, and test code independently, moving beyond simple code completion.The primary challenge is adapting to a world where the initial draft of code is nearly free, shifting focus to problem definition, guidance, and validation.Adopting established software practices like Test-Driven Development (TDD) provides clear goals for AI agents, resulting in more reliable and succinct code.The human engineer's role becomes even more critical, acting as an expert supervisor and architect to guide the AI and ensure quality.