Development with agents

Development teams where

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.

From the assistant to the team that delivers

  1. Today, often

    Assistant

    It completes lines and answers in chat. The person writes everything and the AI suggests. There are no shared rules and no measures.

  2. The first step

    Agent in pairs

    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.

  3. Where the value is

    Hybrid team

    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.

In every phase there is a job for the agent and a decision for the person

Analysis

The agent's work
The agent reads code, documentation and tickets and reconstructs dependencies and impacts.
The person's decision
The person sets the goal and the acceptance criteria.

Design

The agent's work
The agent proposes a written plan, with alternatives and risks, before touching the code.
The person's decision
The person chooses the alternative.

Development

The agent's work
The agent writes the tests and then the code, on an isolated branch.
The person's decision
The person holds the perimeter and decides the non-obvious cases.

End-to-end testing

The agent's work
The agent opens the application in the browser, runs the user journeys, reads the console and the network, and attaches the evidence.
The person's decision
The person looks at the evidence and decides whether it is enough.

Review

The agent's work
The agent rereads the change from several points of view and verifies every finding before reporting it.
The person's decision
The person approves every merge.

Issues and maintenance

The agent's work
The agent opens issues with the steps to reproduce them, takes them on and opens the merge request.
The person's decision
The person sets priorities for the backlog and the releases.

Who decides what, written down first

Every action of the agent falls into one of three bands. The bands are set with you and written in the repository.

The agent acts alone

  • Reading code, documentation and issues
  • Writing tests and code on an isolated branch
  • Running the tests in test environments
  • Opening and classifying issues

Proposes and waits for a yes

  • The plan
  • Every merge request
  • New external dependencies
  • Changes to roles and permissions

Only the person

  • Production releases
  • Irreversible data migrations
  • Changes to the public contracts of the APIs
  • Access to production data, secrets and credentials

Faced with an open question, the agent stops and asks.

Five controls, one behind the other

Each one stops what slipped past the one before.

  1. Written rules

    An instructions file in the repository, with conventions, architecture and decision bands. The agent rereads it at every session.

  2. Minimum permissions

    The agent works on isolated branches and test environments, with no secrets and no access to production.

  3. Guards

    Automated tests that fail when a rule is broken, and block the pipeline.

  4. Human review

    Every merge is approved by a person, on the basis of verified findings and the attached evidence.

  5. Traceability

    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.

Five levels, and not everyone has to reach the bottom

  1. 1

    Individual

    Someone uses an assistant on their own, with no rules and no numbers.

  2. 2

    Assistant

    Company tools in chat and in the editor. The AI suggests, the person writes.

  3. 3

    Agent in pairs

    Bounded tasks given to an agent on the repository, with every step checked by hand.

  4. 4

    Hybrid team

    Agents in parallel on the issues, browser tests, automated reviews, written rules and guards.

  5. 5

    Governed cycle

    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.

Seven modules, each ending with a result

You pick the subset each team needs. The modules adapt to the tools you already use.

1

Foundations

How an agent reasons, what to delegate and what not to, how to verify an output.

The first task delegated and verified.

2

Context and rules

Instruction files, conventions, project memory.

The repository rules, written down.

3

From plan to code

Analysis, written plan, tests before code, review.

A feature delivered with the method.

4

Testing in the browser

Agents that run the user journeys, read the errors and attach the evidence.

The critical journeys verified automatically.

5

Issues and backlog

Opening, classifying, taking on and closing issues, with merge requests.

A tidy backlog, with reproductions.

6

Agents in parallel

Isolated branches, division of work, integration without conflicts.

Several issues moved forward on the same day.

7

Security and governance

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.

By role

Developers

Delegating, verifying, working with several agents.

Tech leads and architects

Writing rules and guards, deciding what gets delegated.

QA

End-to-end tests driven by agents, in the browser.

Product owners

Writing issues that an agent can carry out and a person can verify.

From the snapshot to the autonomous team

  1. 4 weeks

    Assessment

    Questionnaire, repository, observation. Index and level for each team.

  2. 1 week

    Goals

    Workshop with the leads. For each team, a starting number and a target number.

  3. 8-12 weeks

    Training

    Workshops and side-by-side work on the backlog, a team kit in the repositories. Then the following teams.

  4. 2 weeks

    Measurement

    A second assessment with the same indicators. You see which goals were reached and which were not.

  5. monthly fee

    Ongoing care

    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.

Guarantees

Code inside your perimeter

Agents and models run on European tenants or on your own infrastructure.

Secrets never reach the agents

Credentials, tokens and keys stay out of the agents' context; the agents work with minimum, declared permissions.

AI Act and GDPR

Anonymous questionnaire, reviewed with the DPO before it is sent. Human oversight on every merge and every release.

Questions we get

What people ask before signing

For the first team, between eight and twelve weeks, after the assessment. The following teams go faster, because someone who has already been through the path works alongside them.

Contact us

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".

Address
Piazza Maestri del Lavoro 7
20063, Cernusco sul Naviglio (MI)
Italy
Address
Piazza dei Martiri 1
40121, Bologna (BO)
Italy