29 July 2026
Coding with an AI agent: my daily Claude Code + MCP setup
My daily setup for coding with Claude Code, Cursor, and MCP servers: repo context, eval rails, review, deploy discipline, and Brut/Ellipse production lessons.
My coding agent has a clear place in the day
I now code with an AI agent like an extra workshop beside my desk. Claude Code carries the long loops, Cursor keeps the visual cockpit, and my MCP servers bring useful sources into the flow at the right moment. That mix changes my rhythm: I spend more time on product intent, tradeoffs, and system quality, while the agent absorbs a large share of the execution mechanics.
A typical day starts with a concrete slice: improving a RAG flow, adding an eval measurement, cleaning an internal API, wiring an MCP tool, or making an interface clearer for an operational team. Before I launch Claude Code, I write the expected value in one sentence. Then I turn that sentence into paths, constraints, commands, and review criteria. The agent receives an actionable mission, and I keep ownership of the outcome.
The repo tells the product story before the prompt
A strong prompt becomes much stronger when the repo already speaks clearly. I like finding a living README, a useful DOCS.md, well named scripts, a stable tree, visible conventions, and a few representative examples. On an AI project, I also add the business vocabulary, data schemas, main routes, eval commands, and product invariants. That context becomes a rail for the agent and a support for the team.
When I prepare a repo for Claude Code, I think in compact maps. One map explains the domain, another the critical flows, another the tests, another the deployment path. Each map points to exact files. This format keeps context dense, readable, and easy to update. The agent explores quickly, and a human joining the project understands why a decision exists.
Claude Code for long loops, Cursor for close judgment
Claude Code is my tool for tasks that require reading several files, proposing a plan, changing a coherent surface, fixing types, and rerunning validations. I use it heavily for bounded refactors, build fixes, connectors, tests, and pattern migrations. I give it a goal, a boundary, a proof command, and a clear way to summarize the diff back to me.
Cursor stays open all day for close judgment. I read the diff in the editor, rename a sensitive function, compare two approaches, rewrite product copy, and check a UX hypothesis. The duo feels smooth: Claude Code moves the mechanics forward, Cursor keeps me close to intent. That alternation turns the agent into a decision accelerator.
The MCP servers I keep close to the code
MCP becomes valuable as soon as useful context lives outside the repo. In my setups, an MCP server can expose internal documentation, a backlog, a component catalog, fixtures, a log set, product-decision search, or controlled access to test data. The goal is simple: give the agent clean, typed, traceable tools with outputs I can verify.
I start small. Two or three tools are often enough: search a source, fetch a business object, run or read an eval. Then I add tools that truly shorten the delivery loop. A good MCP server feels like a product API for agents: few functions, explicit names, structured responses, and clear responsibility. That simplicity creates speed.
My delivery loop: short plan, readable diff, proof
The loop I use has four beats. First, I ask for a short plan with the files involved and the validation strategy. Then I approve the useful slice and let Claude Code edit. Next I read the diff like a real pair-programming review: names, responsibilities, boundaries, error states, user experience. Finally, I ask for proof: targeted test, build, eval, capture, or controlled request depending on the nature of the change.
This loop works because every step stays observable. The plan says where the agent goes. The diff shows what changes. The validations show what holds. The final summary helps me choose the next move. In client work, that traceability matters as much as speed, because it lets the team maintain the system after delivery.
The guardrails that make speed healthy
My setup rests on concrete guardrails. Evals capture expected behaviors, tests protect technical invariants, logs make decisions inspectable, and reviews keep product meaning at the center. For sensitive features, I also like flags, small deploy batches, and metrics that confirm the change creates a better real experience.
I treat deployment as an engineering discipline, rather than a final ceremony. Each slice needs local proof, diff review, and a clear path to production. On GenAI systems, I often add replayable examples: prompts, inputs, expected outputs, eval score, tool traces. That material turns review into a factual conversation and gives teams a base of trust.
What Brut and Ellipse taught me about production GenAI
At Brut, the media tempo taught me to respect teams that publish fast, verify fast, and understand fast. A useful AI assistant has to fit into an editorial flow, explain its sources, keep acceptable latency, and leave a clear trace. A coding agent follows the same logic: it has to strengthen a real workflow, produce readable proof, and support the quality bar of the field.
At Ellipse, automation and AI work reminded me how much rights, existing systems, integrations, and internal adoption matter. Success usually comes from a series of reliable small loops: understand a business process, connect the right tools, evaluate outputs, ship an increment, listen to users, then solidify. My Claude Code + MCP setup serves exactly that way of building.
The real skill is orchestrating context
The more I use coding agents, the more I see the main skill moving toward context orchestration. The gain comes from repo clarity, example quality, MCP tool choice, ticket granularity, and review discipline. When these pieces are in place, Claude Code becomes a powerful partner for moving from product intent to a verified change.
I like this way of working because it makes engineering feel more human. I spend more time understanding the problem, writing the right constraints, discussing tradeoffs, and handing over a clean system. The agent accelerates fabrication, while the value still comes from judgment, product taste, and delivery responsibility. That is the setup I use daily, and the one I like installing with teams that want to ship AI into production.