27 July 2026
Claude Code in production: my AI engineer workflow
My concrete workflow with Claude Code, Cursor, and MCP for shipping client AI builds: scoping, context, coding agents, reviews, evals, and team adoption.
I treat the coding agent as a production workshop
When I use Claude Code on client work, I start with the same reflex I use for any serious AI build: define the operating system before launching the tool. The concrete project may be a business assistant, a RAG pipeline, an internal interface, an MCP connector, or an eval suite. In every case, I want to know what has to change in the product, which business constraint matters most, which commands prove the change holds, and which part of the repo is the source of truth.
Claude Code becomes highly effective when it enters an organized workshop. I give it a scope, paths, invariants, a Definition of Done, and stop conditions. Then I let it run a full execution loop: read, propose, edit, test, summarize. My role stays the role of a product-minded engineer: choose the right battle, protect the architecture, validate user value, and keep the system simple enough for the team to own after I leave.
Scoping before prompting: objective, context, risk
The highest-leverage part of my workflow happens before the first generated line of code. I turn the request into an executable ticket: target outcome, target user, files to inspect first, existing behavior to preserve, metrics to verify, test commands, and out-of-scope areas. For a coding agent, this framing is as valuable as a good architecture. It reduces noise, speeds up repo navigation, and makes the output much easier to audit.
I also prepare a compact context dossier. For a client build, it often contains a data schema, a log excerpt, the key routes or components, business rules, a few real examples, and known errors. I favor a dense signal over a huge context dump. Claude Code works better with priorities than with a wall of files. This discipline feels close to tech lead work: make the intent legible, then let execution move quickly.
Claude Code for execution, Cursor for close control
I use Claude Code and Cursor for two different moves. Claude Code is my long-loop execution tool: it walks the repo, applies a change across files, fixes types, updates tests, or prepares a bounded refactor. Cursor stays my close-control cockpit: I read diffs, compare options, rewrite sensitive passages, check a product assumption, and review line by line. The pair works well because it separates execution mechanics from nearby judgment.
On a real client project, that separation changes speed. I can ask Claude Code to handle one precise slice while I keep Cursor open on the critical files. When the loop returns, I am not only checking whether the code compiles. I look at whether the product intent survived, whether the change surface is healthy, whether the names tell the right story, and whether the test protects the right invariant. That rhythm gives me more time for judgment while compressing the mechanics.
MCP gives agents usable context
MCP has become an important part of my workflow because it turns context into an interface. Instead of manually pasting documentation excerpts, schemas, or procedures, I prefer exposing clean tools: document search, ticket access, component catalog lookup, controlled queries, fixture generation, or test-environment inspection. For a team, this is much more durable than a set of private prompts sitting in everyone's notes.
A good MCP connector is small, legible, and use-case driven. It gives the agent what it needs to act, with structured outputs and clear limits. In my builds, I often start with only two or three tools: find a source, retrieve a business object, produce a verifiable report. Then I add what materially improves the shipping loop. MCP becomes a production rail for agents, rather than a technical showcase.
The loop that ships: plan, slice, test, review
My standard loop has four steps. First, Claude Code reads the scope and proposes a short plan. Then it implements a slice that can be reviewed on its own. Next, it runs the planned validations: lint, build, targeted tests, sometimes a business eval or browser scenario. Finally, it returns with changed files, what was verified, and the points that deserve a human decision. This loop creates a clear trace and keeps the work moving in controlled increments.
The strongest tasks have a visible contract: add a route, stabilize a component, migrate a schema, wire a tool, complete a test suite, harden a production error. The areas that require the most care are product tradeoffs, architecture choices, broad migrations, and topics where real data is thin. In those cases, I shrink the slice and bring the product owner or senior engineer into the loop earlier.
From my workflow to a production team
The real challenge for a client team is turning my personal workflow into a shared system. So I document the best prompts as playbooks, add repo-level instruction files, keep validation commands visible, name MCP tools by use case, and define a review policy for coding-agent output. The goal is simple: the team knows when to launch Claude Code, how to constrain its scope, how to review its output, and how to decide that a change can go to production.
When this works, agentic coding becomes an engineering practice instead of a magic moment owned by one person. Junior developers get a clearer frame. Senior engineers recover time on mechanical work. Product leaders get shorter loops and more explicit decisions. That is the version of Claude Code I care about: a delivery accelerator, connected to Cursor, powered by MCP, measured through tests and evals, and clear enough to live inside a real production team.