We turn the use of coding agents into a repeatable, reviewed engineering process in your repository — measured on real work, not on the number of lines generated. This page is about agents in developers' hands, not agents in business processes — those are covered under AI agent implementation.
This page is not about agents that handle the company's business processes — reading tickets, updating the CRM, preparing quotes. Those are covered under AI agent implementation, linked above, and there the project starts with permissions in the company's systems. This page is about coding agents — Claude Code, GitHub Copilot, Cursor and the like — in developers' hands: making their use in your repository stop depending on who happens to be at the keyboard, and become a process the team repeats, reviews and measures.
A CTO, head of engineering or software-house owner who already pays for agent tooling and sees one of three things:
The common denominator: the tool is there, the process is not. A licence will not fix that — rules in the repository, gates and review will.
The stages, the concrete deliverable at the end of each and the split of decisions are the same as in every project we run — they are set out in our delivery methodology. The process in the repository is also often one stage of a wider AI implementation.
We sign off when:
We measure four things, before and after: time from picking up a task to merging it (lead time), reviewer time per change, the share of changes reworked after review, and the number of defects that reached production. We do not measure lines of code generated — that number also rises when a team gets worse.
We do not run courses or workshops on coding agents — neither open enrolment nor in-house. A workshop in a room, after which the team returns to a repository with no rules, no gates and no review, changes little. Learning here is part of the implementation: it happens on your code, on your tasks, and ends in a process that stays in the repository rather than in slides. We treat training the same way in every AI implementation — see what we don't do.
We advise against the project when the build is unstable, there are no tests or nobody owns the code — the agent would then only speed up the production of technical debt.
A coding agent sends fragments of code to the model provider. On what terms, how long they are retained, how company accounts differ from private ones and what applies to MCP servers — we set that out using the example of Claude Code for business; a comparison of the plans and terms of other tools is in our note on Copilot, ChatGPT and Claude for business. A company account, not a private one, is a condition of starting. The split of roles for personal data — and a repository holds more of it than you think — is on our security and GDPR page.
A fixed scope and a fixed price for a specific stage — not open-ended consulting hours.
For teams that want to keep the process working after a change of tool or model, we offer care after handover within an agreed hour allowance, during business hours, with no promise of 24/7 availability.
No. We do not run courses or workshops on coding agents — neither open enrolment nor in-house. This is the implementation of a process in one repository: the agent's instructions and permissions, task templates, tests and CI gates, review requirements, and the team's practice on real backlog items. The team learns along the way, but what remains after the project is a process in the repository, not a slide deck.
The one your team already licenses or is about to license — most often Claude Code, GitHub Copilot, Cursor or Codex. We do not sell licences and we do not choose the tool for you; if the choice is still open, our note on Copilot, ChatGPT and Claude for business sets out how the plans and terms differ. We connect an MCP server only when the process genuinely lacks an integration, not because it is fashionable.
We set the scope and the price after seeing the repository — the build, the tests, CI and the way reviews are done — and after choosing one family of tasks from your backlog. Pricing is per stage, at a fixed scope and a fixed price: one team, one repository, one family of tasks, agreed before-and-after measures. The first stage is usually counted in weeks. Tool licences and model usage sit outside the quote.
It can — which is exactly why the process starts with review rules, tests and CI gates rather than with prompts. A change written with an agent passes the same gates as any other, and the reviewer gets a list of what to check in such a change. We measure quality before and after: the share of changes reworked after review and the number of defects that reached production. If those numbers rise, the process needs fixing, however much code was produced.
Three conditions are non-negotiable: a company account, not a private one; rules that forbid the agent to read secrets and data or to run commands outside the permitted scope; and no access to production. A coding agent sends fragments of code to the model provider — on what terms, how long they are retained and what applies to MCP servers is set out in our note on Claude Code for business. The split of roles for personal data is on our security and GDPR page.
Let's pick one — tests, a bounded feature, a reproducible bug — and check on it whether an agent in your repository produces a measurable result. We will also say outright when the build has to be fixed first.
Last updated: