Part 5 ended with a debt: autonomy I am willing to grant, and guardrails that hold even when the model would rather keep going.

This is Part 6 of 6 in my Agentic Coding with Claude Code series. The working model I am keeping is simple: eval tells me whether the loop did the job. Guardrails decide what the loop is allowed to do even when the model wants another hop. Bounded autonomy is the grant: which agents, which tools, how many turns, when a human is required.

This is the series closer. I will not rewrite Parts 1 through 5. I will bound the loop those posts already built.

Read More

Part 4 ended with a debt: whether the loop is actually doing the job. When a skip was correct, when a tool lied, and when the audit trail is the only honest record.

This is Part 5 of 6 in my Agentic Coding with Claude Code series. The working model I am keeping is simple: evaluation is how I score a run. Observability is how I see the run. Structured output is the seam between them.

A harness that cannot tell success from a polite hallucination is a demo. Later I will talk about bounded autonomy. This one stays on scoring the loop and seeing it.

Read More

Part 3 ended with a debt: tools that live outside the process, MCP servers, how they enter the window, and how to keep that surface small.

This is Part 4 of 6 in my Agentic Coding with Claude Code series. The working model I am keeping is simple: the model still reasons. The harness still decides. MCP is how tools and context live outside the process and still enter the window as a governed surface.

Later posts will cover evaluation and observability, then bounded autonomy. This one stays on the MCP boundary.

Read More

Part 2 ended with a debt: when I own the runtime, I have to implement trim, a facts block, tiered compress, and placement myself. Claude Code already does a version of that. A product I ship does not get it for free.

This is Part 3 of 6 in my Agentic Coding with Claude Code series. The working model I am keeping is simple: the model reasons, the harness decides what happens next.

Claude Code is one harness. The Agent SDK is that same loop as a library. The Messages API is the loop with the cover off: every response has a stop_reason, and your code chooses whether to run a tool, ask the user, route, escalate, or halt.

Later posts will cover MCP, evals, and guardrails. This one stays on the runtime around the model.

Read More

In Part 1, I treated Claude Code as a bounded loop: perceive, reason, act, then feed the evidence back in. The reasoning engine is only as good as the working set it sees. A precise goal still fails if the window is full of directory trees, stale chat, and a vague tool contract.

This is Part 2 of 6 in my Agentic Coding with Claude Code series. The working model I am keeping is simple: context is assembled, not typed, and it is a budget, not a bucket.

CLAUDE.md, path-scoped rules, skills, memory, tool results, and the conversation all compete for the same tokens. Unfiltered tool output is paid for on every later turn. The job is to load the right slice at the right time.

Later posts will cover the harness and Agent SDK, MCP, evals, and guardrails. This one stays on the context layer that shapes every decision in the loop.

Read More

Most people first meet Claude Code as a chatbot in a terminal. That mental model is too small.

Ask it to explain a bug and it may answer once. Give it a concrete engineering objective and permission to work, and it can read the repository, trace the code, edit files, run tests, inspect the result, and change course when the evidence contradicts its plan. That repeated cycle is what makes the workflow agentic.

This is Part 1 of 6 in my Agentic Coding with Claude Code series. The working model I am keeping is simple: Claude Code is a bounded loop of perceive, reason, act, and feedback, not a longer chatbot reply.

Later posts will cover context, the harness / Agent SDK / stop-reason loop, MCP, evals, and guardrails. This one stays on the loop, the components, and the patterns.

Read More