Introduction

Chances are, if you're reading this, that within the last year or so you've had your "AI moment" where you watched an agent do something that would've taken you all afternoon in the time it took to refill your coffee.

The capabilities that have emerged from these technologies are genuinely mind-blowing, and they've allowed individuals or small teams to exponentially increase their output. Simply giving one of these agents a few lines of instructions can generate applications in minutes that previously would've taken weeks. However, if you stick with it long enough, you'll hit the inflection point where these agents start to break down.

Just like humans, agents only understand what you tell them -- and they can only keep so much in their "brain" at a given time. The interesting part isn't that agents fail, it's where they fail; writing code is no longer the bottleneck, everything around it is.

The economic inversion

Writing code used to be a bottleneck: a simple feature request could take hours of developer time and co-ordination with multiple people. Programmers were once in short supply, and the ability to translate instructions into syntax was a prized skill.

LLMs have destroyed the status quo; a coding agent will happily generate thousands of lines of code before you've had time to read the first hundred.

This has created a strange economic property: code has never been cheaper to produce, and yet good code has never been more expensive. The scarce resource is no longer production of code, but judgement. Someone, or something, still needs to verify that the plausible-looking output is actually correct.

This is a genuine inversion of how the software industry has worked. For decades the limiting factor was how fast a team could write correct code, and we built everything around that constraint.

The thesis

The core hypothesis of this guide is that the fundamental software engineering principles have not changed, only the way we write code has. And, as any good software engineer will tell you, writing the code was never the hard part.

Abraham Lincoln was quoted as saying,

Give me six hours to chop down a tree and I will spend the first four sharpening the axe.

This guide will teach you how to sharpen the axe: how to choose the right tools, how to configure them to get the best results, how to plan your development cycle, and how to leverage AI while staying in control.

Proper software engineering methodology and discipline are not obstacles that coding agents let you skip; they are precisely the instruments that make agents effective and trustworthy.

What this guide is

This guide aims to present a structured methodology to building production-grade software with coding agents, and that starts with demystifying the technology that powers them -- Large Language Models, or LLMs.

Most people today treat AI as a magic black box, and trust that its output is correct -- this is a mistake.

Who this guide is for

The goal in writing this guide is that anyone can leverage these processes to build dependable software applications, although it is worth noting that experienced software engineers will likely see the greatest productivity increase.

The one thing AI cannot do is be a substitute for experience. A trained eye will be able to spot plausible-yet-incorrect output far quicker than a novice. Develop an eye for detail and learn to spot common pitfalls, and you will see much better results.