Working with an AI coding agent

This whole site exists because of a bet: that the durable skill is not typing syntax from memory, but knowing what to build and being able to tell whether it was built correctly. Nowhere is that clearer than when you work with an AI coding agent. Used well, an agent is a force multiplier. Used carelessly, it's a very fast way to ship confident nonsense.

The right mental model

Treat an agent as a brilliant, tireless, slightly overconfident junior engineer with encyclopaedic recall and no real-world stakes. It can produce a lot of plausible code quickly. It does not truly know whether that code is correct, whether it fits your system, or whether the library it called even exists in the version you use.

That framing tells you your job. You are the senior: you set direction, you define "done," and you review. The agent supplies speed; you supply judgement. If you outsource the judgement too, you no longer understand your own program — and you'll find out at the worst possible time.

Setting an agent up to succeed

The quality of what you get back is mostly decided by the quality of what you ask. A few habits do most of the work:

• State the goal and the constraints. Not just "add login," but "add email + password login using our existing User model; don't add new dependencies."
• Give it the context it can't guess. Point at the relevant files, the conventions, the thing it should match.
• Ask for small, verifiable steps. A change you can read in one sitting is a change you can actually review. Giant diffs hide bugs.
• Say how you'll know it worked. "It should pass these tests" or "it should handle an empty list" turns a vague request into a checkable one.

This is the same skill as decomposition and the same skill as writing a good spec. The fundamentals reinforce each other.

Verify, don't trust

The single habit that separates people who thrive with agents from people who get burned: verify the output against ground truth, every time. Concretely:

• Read the code. If you can't follow what it does, you can't approve it. Ask the agent to explain anything opaque — then confirm the explanation.
• Check the seams. Where the generated code calls a library or another part of your system, confirm those calls are real and correctly shaped (the documentation lesson is your friend here).
• Run it. Tests, the actual app, an edge case by hand. Behaviour is the final authority, not the agent's confidence.

Why this is a fundamental, not a trick

It's tempting to think prompting is the new skill and the old fundamentals are obsolete. The reverse is true. To direct an agent well you must understand the problem; to review its work you must understand programs, data, and systems; to catch its mistakes you must be able to read code and docs. Agents raise the ceiling for people who have the fundamentals and quietly lower the floor for people who don't.

That's the bet this camp is making — and why you're starting here.

Where to go next

You've now got the core mental models. From here you can branch into a language track to practise the syntax, or continue into Systems & Structure to learn how whole systems fit together.