Series: A Practitioner's Guide to AI-Assisted Development

I did not move from AI sceptic to daily agent use in one smooth step. This series maps the uncomfortable transitions and what each asks developers to give up.

Coding agents have reduced the cost of producing code. The scarce work is increasingly defining systems: contracts, invariants, service levels, and verification.

One study found experienced developers were slower with AI while believing they were faster. The gap suggests an exoskeleton: useful amplification that still depends on human judgement.

The setup checklist I wish I'd had on day one with Claude Code: isolation, terminal configuration, code intelligence, context monitoring, and what not to install.

Research suggests auto-generated context files can hurt agent performance. A short, human-curated CLAUDE.md works better when it contains only what the repository cannot explain.

Teresa Torres's three-layer context system and Patrick Zandl's claudecode-kb show how to preserve useful context between sessions without loading everything every time.

A prompt is only one part of what an agent sees. This four-layer framework covers instructions, context, intent, specifications, and when each belongs in the workflow.

An agent does not need your entire knowledge base in every prompt. It needs a structure that reveals the right instructions, memories, and source material when the work calls for them.

AI agents amplify the engineering process around them. I compare three workflows that separate planning from execution, and explain where each is worth the ceremony.

Coding agents are good at iterating towards a result, provided we define that result independently. Tests, contracts, and feedback loops make it easier to detect when an implementation has drifted from our intent.

A context window is a budget. These are the tactics I use to manage it: scope each session, write durable state to disk, isolate research, and clear between phases.

MCP offers discovery and a standard interface; CLIs offer composability and familiar controls. I compare their costs and explain why my default is CLI-first, not CLI-only.

Skills can encode Standard Operating Procedures without loading every instruction upfront. One activation experiment shows why descriptions, evals, and hooks still matter.

Boris Cherny's workflow is less exotic than its throughput suggests: plan first, run agents in parallel, give them reliable verification, and turn repeated work into shared tooling.

Agents can produce working code faster than we can absorb it. Walkthroughs, executable examples, and interactive explanations help repay the cognitive debt before an unfamiliar system becomes our problem.

A sandbox limits what an agent can damage while it works; it cannot tell you whether the resulting code is safe to ship. AI-assisted development needs separate controls for the runtime and the artefact.

Agents do not abolish the work between an idea and a dependable production result. They compress its hand-offs into a tighter loop, moving the bottleneck from writing code to specifying, verifying and learning.

Coding agents work well because repositories provide structure, history and checks. The same tools can help elsewhere, provided we give those workflows equally clear inputs, narrow permissions and visible results.

The difficult step in agent-assisted development is not enabling an autonomy flag. It is replacing constant approval with constraints strong enough to deserve our trust.

When an agent writes the implementation, the specification becomes our main engineering interface. That makes ambiguity, premature detail, and untested assumptions more expensive than they first appear.

Faster code generation only helps when the rest of the system can reject bad work quickly. Tests, static checks, and CI provide the backpressure that makes greater agent autonomy sustainable.

Line-by-line review does not scale with agent output, but abandoning review is not the answer. A risk-based approach moves attention towards invariants, interfaces, dangerous changes, and evidence.

A capable model is only one component of a dependable coding agent. The harness decides what context it sees, which actions it can take, how it receives feedback, and when it must stop.

Adding a second agent is not a linear productivity upgrade. Work decomposition, review capacity, shared state, and cost all become coordination problems rather than prompting problems.

Parallel agents need more than separate terminal tabs. Useful concurrency depends on task boundaries, isolated workspaces, explicit ownership, and an integration path designed before the agents start.

Agent teams can divide by task, role, or stage of work, but every extra communication path adds failure modes. The useful pattern is usually the smallest topology that matches the dependency graph.

An overnight agent loop sounds like unattended productivity. In practice, the useful work happens before and after the run: bounded specifications, independent checks, forensic records, and a morning decision.

A few shell scripts can coordinate a small fleet surprisingly well. Beyond that point, durable state, retries, routing, observability, and recovery turn the experiment into an orchestration system.

A human can supervise several agents, but attention does not scale with token spend. Past a certain point, adding workers increases queues, conflicts, and missed failures faster than useful output.

Once agents produce most implementation code, the durable asset is the factory around them: specifications, tools, feedback, state, evaluation, and recovery. Building that factory is a different engineering job.

Formal methods have traditionally been expensive specialist work. If agents can help write specifications, proof harnesses, and models, the economics may change, but proof obligations and scope still need human judgement.

An AI-native organisation is not a conventional team with more licences. Its processes, review capacity, incentives, and ownership model have to change when implementation is no longer the scarce resource.

Agent fluency can make an implausible number of projects feel possible. The final skill is not learning to automate everything; it is deciding which possibilities deserve the cost, risk, and attention.

My starting point for a disposable Hetzner agent box: cloud-init hardening, Tailscale access, optional Cloudflare Tunnel, resource planning, and automation scripts.

The Claude Code configuration I use bundles plugins, skills, CLI tools, and sandbox settings into one installer. Treat it as an opinionated starting point, not a universal setup.