1
Foundations
How an agent reasons, what to delegate and what not to, how to verify an output.
The first task delegated and verified.
Development with agents
people and agents work together
Writing code is only one part of it. Today an agent can analyse a request, propose a plan, try the application in the browser, open and close an issue. The difference comes from a team that knows how to guide it, check it and give it rules. We teach it on your own code.
Today, often
It completes lines and answers in chat. The person writes everything and the AI suggests. There are no shared rules and no measures.
The first step
It takes a bounded task and carries it out on the repository. It reads the code and writes tests and changes. The person checks every step, and their time shifts from writing to checking.
Where the value is
Several agents in parallel, each on one issue and isolated from the others. They analyse, develop, test and open merge requests. The rules are written in the repository, and people decide and review.
Many teams stop at the first stage. Getting to the third takes a method; the licence alone is not enough.
| The agent's work | The person's decision | |
|---|---|---|
| Analysis | The agent reads code, documentation and tickets and reconstructs dependencies and impacts. | The person sets the goal and the acceptance criteria. |
| Design | The agent proposes a written plan, with alternatives and risks, before touching the code. | The person chooses the alternative. |
| Development | The agent writes the tests and then the code, on an isolated branch. | The person holds the perimeter and decides the non-obvious cases. |
| End-to-end testing | The agent opens the application in the browser, runs the user journeys, reads the console and the network, and attaches the evidence. | The person looks at the evidence and decides whether it is enough. |
| Review | The agent rereads the change from several points of view and verifies every finding before reporting it. | The person approves every merge. |
| Issues and maintenance | The agent opens issues with the steps to reproduce them, takes them on and opens the merge request. | The person sets priorities for the backlog and the releases. |
Analysis
Design
Development
End-to-end testing
Review
Issues and maintenance
Every action of the agent falls into one of three bands. The bands are set with you and written in the repository.
Faced with an open question, the agent stops and asks.
Each one stops what slipped past the one before.
An instructions file in the repository, with conventions, architecture and decision bands. The agent rereads it at every session.
The agent works on isolated branches and test environments, with no secrets and no access to production.
Automated tests that fail when a rule is broken, and block the pipeline.
Every merge is approved by a person, on the basis of verified findings and the attached evidence.
Every commit carries the agent as co-author, and every decision sits in the issue or the merge request.
When a mistake gets through anyway, it becomes a new rule or one more test. From then on it applies to every agent and every person on the team.
1
Someone uses an assistant on their own, with no rules and no numbers.
2
Company tools in chat and in the editor. The AI suggests, the person writes.
3
Bounded tasks given to an agent on the repository, with every step checked by hand.
4
Agents in parallel on the issues, browser tests, automated reviews, written rules and guards.
5
Agents along the whole cycle, metrics per team, cost per issue, rules that improve with every mistake.
Whoever works on payments and whoever builds prototypes have different goals and constraints. The assessment tells you where each team stands and where it makes sense for it to be.
You pick the subset each team needs. The modules adapt to the tools you already use.
1
How an agent reasons, what to delegate and what not to, how to verify an output.
The first task delegated and verified.
2
Instruction files, conventions, project memory.
The repository rules, written down.
3
Analysis, written plan, tests before code, review.
A feature delivered with the method.
4
Agents that run the user journeys, read the errors and attach the evidence.
The critical journeys verified automatically.
5
Opening, classifying, taking on and closing issues, with merge requests.
A tidy backlog, with reproductions.
6
Isolated branches, division of work, integration without conflicts.
Several issues moved forward on the same day.
7
Secrets, data, permissions, costs. What an agent can never do.
The guards active in the pipeline.
Every module ends with something done in your repository. The certificate, if you need one, comes after.
Delegating, verifying, working with several agents.
Writing rules and guards, deciding what gets delegated.
End-to-end tests driven by agents, in the browser.
Writing issues that an agent can carry out and a person can verify.
4 weeks
Questionnaire, repository, observation. Index and level for each team.
1 week
Workshop with the leads. For each team, a starting number and a target number.
8-12 weeks
Workshops and side-by-side work on the backlog, a team kit in the repositories. Then the following teams.
2 weeks
A second assessment with the same indicators. You see which goals were reached and which were not.
monthly fee
Monthly indicators and reports, support for the teams, updated rules.
You start from a pilot team. Those who have been through the path then work alongside the colleagues of the next team.
Agents and models run on European tenants or on your own infrastructure.
Credentials, tokens and keys stay out of the agents' context; the agents work with minimum, declared permissions.
Anonymous questionnaire, reviewed with the DPO before it is sent. Human oversight on every merge and every release.
A quote, a particular request, or simply a coffee to get to know each other? Write to us and we will reply in a "nanosecond".