The habits that make it click

The gap between people who love agentic coding and people who find it frustrating is almost never the tool. It's a handful of habits — and they're all small.

Interrupt early

The single most expensive thing you can do is watch it go the wrong way and hope it self-corrects. It usually won't, and every step it takes makes the diff harder to unpick.

The moment you think "that's not what I meant" — stop it. Escape is right there. Thirty wasted seconds is nothing; five wasted minutes and a tangled diff is a bad afternoon.

Restart beats rescuing

When a session has gone genuinely sideways — three failed attempts, a context window full of dead ends, a growing pile of half-changes — the instinct is to keep pushing. Don't. That session is now more likely to fail: it's full of its own wrong turns, and it will keep referring to them.

Revert the mess, start fresh, and open with what you learned:

Add retry logic to the webhook sender in src/jobs/webhook.ts.

Note: the obvious approach of wrapping the fetch in a loop doesn't work here —
the job runner already retries at a higher level, so it double-fires. Look at
how src/jobs/email.ts handles this and follow that pattern.

Two minutes of typing beats twenty minutes of a poisoned session. And notice what that prompt is: the findings of the failed session, carried forward as context. The session was not wasted — it was research.

Keep the loop tight

Everything good in this course points the same direction: small tasks, checked often.

• One job per session, ending in a working, committed state.
• A finish line you can run — a test, a command, an output.
• A diff small enough that you actually read it.

It feels slower than firing off one enormous request. It is dramatically faster, because you never spend an hour discovering that the last fifty minutes were built on a misunderstanding.

Pick the model on purpose

Different jobs deserve different models, and switching is one command (/model):

• Claude Opus 4.8 — the most capable. Reach for it on hard, long-horizon work: gnarly debugging, multi-file refactors, anything where being right matters more than being quick.
• Claude Sonnet 5 — a strong balance of speed and intelligence; near-Opus quality on a lot of coding work, and quicker.
• Claude Haiku 4.5 — fastest and cheapest, for short, simple, well-specified jobs.

If the work is hard, don't economise — a cheaper model that gets it wrong costs you a session, not a few cents. Claude Code also has a fast mode (/fast) on the Opus 4.8 tier: same model, faster output, for when you're iterating interactively and waiting is the bottleneck.

Know when not to use it

Using it well includes not reaching for it:

• When you don't know what you want. An agent will happily build the wrong thing quickly. Figure out the what first — it's fine to think out loud with it, just don't let it start editing while you're still deciding.
• When you can't verify the result. If neither of you can tell whether it worked, you haven't produced code — you've produced risk that looks like code.
• For the three-line change you can already picture. Typing it is faster than describing it.
• When you're learning something on purpose. Delegating the reps to an agent is exactly the wrong trade if the point was to build the skill.

The whole course in one line

If you keep one thing:

That's it. Set up a CLAUDE.md today, ask for a plan on your next real task, and make it run the tests before it tells you it's done. Those three habits will do more for you than any prompt trick — and everything else here is just refinement on top.