Agentic coding for engineers who already ship.

01

Context engineering, not prompt cleverness

The first instinct is to write a better prompt. The leverage is in the context — what the model can actually see when it reaches for an answer. The right files, the failing test, the constraint that isn't written down anywhere, the directory it's allowed to touch. Get the context right and a blunt prompt works; get it wrong and the cleverest prompt in the world hallucinates an API that doesn't exist. Treat the context window as a thing you engineer, deliberately, the same way you'd engineer the inputs to any other system.

02

Using Claude Code (and tools like it) well

Knowing how to use Claude Code well is mostly knowing when to let it run and when to stop it. Scope the task so the agent has a clear target and a tight blast radius. Give it the commands to verify its own work — the test, the typecheck, the build — and make running them part of the loop, not a thing you do afterward. The engineers who get the most out of these tools aren't the ones who type the least; they're the ones who set up the problem so the agent can't drift far before it hits a wall it has to climb.

03

AI pair programming that earns its name

A good pair pushes back. Most AI pair programming setups don't — the model agrees with you, implements the happy path, and tells you it's done. The fix is to make disagreement part of the workflow: ask it to argue against its own design, to find what breaks under load, to name the edge case it skipped. Pairing with an agent is worth it when you treat its first answer as a draft to interrogate, not a verdict to accept. The reviewer in the loop is still you.

04

Broad prompting: never accept "I'm done"

Broad prompting is my own frame for it, and it's the single habit that separates working code from production code. Your agent will stop at "it works." You shouldn't. After every implementation, audit it broadly — security, error handling, edge cases, performance, the failure modes nobody asked about — then feed that audit back in as the next prompt. The difference between code that runs on your machine and code that survives production is usually about ten rounds of "what else could go wrong?" That's not a mindset; it's a loop you run on purpose.

05

Verification: finished is not correct

An agent edits eleven files, runs a command, and reports a green checkmark. "I ran the tests and they passed" and "the tests passed" are different sentences, and the gap between them is where the failures live. The agent's account of its own run is a story it tells after the fact, reconstructed from a context window it has probably already compacted. So don't trust the summary — read the receipt. Re-derive the diff, re-run the check yourself, and demand an audit trail you can inspect without trusting the thing that produced it.

06

The agent-shaped gap

There's a gap between what an agent can do and what it's actually asked to do, and most of the disappointment with these tools lives in that gap. Closing it isn't a bigger model — it's orchestration: scoping, sub-agents, verification gates, the workflow that turns a capable model into a reliable one. That gap is exactly why I started building tooling around the raw API instead of waiting for the next release to fix it for me.