AI coding agents: how we organise their work

Camille Wanty
·
·
An agent can write code in minutes. Handing it part of a product’s development is mostly a matter of organising everything around it.
VOLTA is made up of a web application, an API, a database and a calculation engine, all developed by a small team. We now use agents at several stages of development, from triaging a bug to drafting a release note.
An agent needs to know which work to pick up, where to find the context, which rules to follow, how to check its output and when to stop and let a human decide. That is the system we have built around VOLTA.
Our approach draws on Shape Up, Basecamp’s product development method, and on pstack, a set of practices for working with agents. We adapted both to our product and our constraints.
Basecamp as the source of truth
All work starts in Basecamp.
A bug, a product request or a piece of QA feedback becomes a card. Its column shows its status: needs clarification, ready, in progress or ready for QA. Important decisions are kept in the body of the card, even when they were first made in the comments.
This discipline existed before agents. With them, it became essential.
An agent picking up a topic cannot rely on a Slack conversation that has scrolled away or on the memory of whoever created it. The card has to hold enough information to understand the problem, find the decisions and carry on with the work.
The agents help keep the cards in shape themselves. They rewrite cards, flag missing information and add links to the tasks, branches and pull requests they create.
Two workflows: bugs and features
We defined one workflow for bugs and another for features.

Features and bugs follow two separate workflows. Human decisions stay visible at the steps that commit the product.
For a bug, a first agent reviews the report. It checks the context, the affected version and the steps to reproduce. If a key piece of information is missing, it asks a targeted question and stops. Otherwise, it normalises the card and moves it to the ready queue.
A second agent can then reproduce the problem, look for its cause, propose a fix and add a regression test. It then opens a draft pull request. The card keeps the links and moves to QA.
The feature workflow starts earlier. The agent first helps turn an idea into a problem that is precise enough to work on. It then explores the affected parts of the product before estimating its size. This step avoids guessing the technical complexity from a mock-up.
Once the scope is accepted, another agent prepares the technical approach and the build tasks. Development moves forward in verifiable chunks. A task is only done when the code and its tests pass.
After approval, the agent can also prepare the user acceptance test and the release note. The release note describes the benefit to the user without exposing the details of the code.
Every transition leaves something durable behind: an updated card, a task list, a branch, a pull request or an acceptance test scenario.
The know-how lives in the repository
We did not build this with a collection of personal prompts.
Each step is described in an instruction file versioned with the code. We call these files skills. They set out the starting point, the expected result, the mandatory checks and the situations in which the agent must stop.
The repository also holds instructions for recurring technical operations: creating a database migration, adding a field across every layer of the product, changing translations or extending our API for agents.
A change to the way we handle bugs therefore goes through a pull request. The team can review it and trace its history. The same instructions work with several tools, including Codex and Claude Code. A new agent starts with the rules the team has learned over time.
Some of these rules cover mistakes that are hard to spot. For example, our API can silently ignore a parameter that was not declared in its contract. Without an instruction or an automated check, the call succeeds but returns too much data. So the repository explains how to change that contract and how to check the result.
Automate what must be repeatable
We do not ask agents to redo every operation freely.
When an action must produce exactly the same result every time, we implement it in a command-line tool. Our internal tool creates branches with the right metadata, checks migrations and translations, validates some contracts and gathers the changes that go into release notes.
Commands that change the repository start by showing a preview. An explicit confirmation then triggers the action. They also produce structured output that the agent can read without having to interpret free text.
The agent chooses the action. The tool carries out the mechanical part.
This separation matters. A model can make sense of an ambiguous report or compare several solutions. A program remains more reliable for applying the same naming convention two hundred times.

The agent exercises judgement, the tool guarantees repeatability and the human makes the final decision.
Humans keep the important decisions
This setup does not make development autonomous.
An agent can triage, explore, write, change code and run checks. It does not decide on its own that a feature meets the need, that a product trade-off is acceptable or that a version can be released.
So we place human approvals where responsibility changes hands: accepting the scope, reviewing the pull request, acceptance testing and release.
Our goal is not to take humans out of the loop. It is to give them documented, verified and traceable work at the moment their judgement adds the most value.
Every mistake should improve the system
The most useful part of this setup may be its ability to retain lessons.
When a mistake happens again, we do not just fix the code. We look for what is missing around the agent: an instruction, a check, a piece of information on the card or a deterministic tool.
The silently dropped API parameter is one example. After it happened twice, we added an automated check. Catching that mistake no longer depends on the next developer’s vigilance.
That is what our “agentic software factory” really comes down to. It gradually turns the team’s mistakes into executable rules and one-off decisions into shared knowledge.
The agent speeds up the work. The system around it is what makes it trustworthy.
Previous






