Bad code is the most expensive it's ever been.

While agentic coding is powerful, it introduces new engineering challenges around control, reliability, and maintainability.

The goal is not to make agents write more code; it is to make them produce code that stays easy to change.

So why does this matter?

Agentic engineering starts from a simple observation: large language models are no longer just autocomplete systems. In many workflows, they behave more like interpreters. The "program" is not only code. It is the whole input you give the model:

• instructions
• constraints
• files, examples
• tools
• state
• environment

In that sense, the context window becomes the new execution surface.

In an agentic system, some behavior is still encoded in code, but a meaningful part of the system is produced at runtime from language, context, and tool use. The practical question becomes "what capability do we give the agent, and how do we shape its judgment?”

These systems are stochastic. They can be useful, capable, and often impressive, but they are not inherently verifiable in the way ordinary programs are. The core research problem in this paradigm is verifiability.

This is why prompting alone is not enough. You need:

• orchestration
• evaluation
• interfaces
• tool design
• environment control
• testable boundaries
• reviewable outputs

Hence, setup matters a lot. The problem this guide is trying to address is how we can design reliable systems with non-deterministic intelligence.

Software 3.0

What’s described above is sometimes described as Software 3.0: software is increasingly specified in natural language and executed through models. The agent carries packaged intelligence and adapts its actions to the local environment. Instead of building a fixed application for every narrow workflow, you can often describe the task and get a bespoke solution for that situation.

Here is what the division of tasks is likely to look like in Software 3.0:

1. Deterministic (old school) software serves as infrastructure, boundary, and tool.

   This is so that we can manage persistence, permissions, computation, integration, testing, and enforcement.

2. The neural network handles interpretation, synthesis, and adaptation.

This is why agentic engineering is not mainly about making software generation faster. Some of the value is speed, but the deeper change is that new kinds of systems become possible. Agents can inspect a codebase, form a plan, use tools, recover from intermediate failures, and adapt their approach to the environment. That is qualitatively different from ordinary automation.