How we use AI in development

We use coding agents for implementation, analysis, documentation and tests. Engineers decide the architecture, resolve product trade-offs and approve releases.

Agents work from the project backlog and repository instructions. Each change goes through automated checks, a separate model review and an engineer’s review. We test the changes in a test environment before approval.

How a task reaches production

1. Each backlog task that is ready for work includes the expected behavior, context, constraints and acceptance criteria. Scheduled agents check the queue and pick up eligible tasks.
2. The agent reads the instructions and code relevant to the task, then makes the changes on its own branch. It runs the project’s required checks before submitting the work for review.
3. Examples and automated tests describe new behavior. For a confirmed bug, the agent reproduces the problem and, where practical, writes a failing regression test before making the fix.
4. A second model reviews the change for incorrect assumptions, edge cases, security risks and missing tests. The engineer receives its findings as part of the review.
5. The delivery pipeline builds the branch and deploys it to an isolated test or preview environment. The change can then be tried before it is merged.
6. An engineer reads the code changes, tests and model-review findings, then checks the running software. They can request changes, reject the approach or approve it. Agents cannot approve their own work.
7. After engineer approval, the automated pipeline builds the release and deploys it through the project’s agreed production process.

Instructions live with the code

We version agent instructions in the repository. They cover architecture, naming, imports, component patterns, accessibility, data handling and the commands needed to check the work. Each task has acceptance criteria.

Agents must reuse suitable existing code, explain decisions that need context and avoid unnecessary dependencies. If a task conflicts with the architecture or requires a product, security or privacy decision, the agent raises it with an engineer.

Reviewers check the change against those instructions and the behavior agreed for the task.

What each review checks

Automated checks verify types, tests, builds and repository rules. A second model reviews the code for mistakes and missing cases. These checks can catch problems before the engineer reads the change.

The engineer decides whether the implementation fits the architecture and whether the tests cover the required behavior. They also assess product trade-offs and security-sensitive choices, and approve the release.

Where agents can work

Development

Agents can inspect the repository, make scoped changes on their own branch and run project checks. These changes do not affect users.

Test and preview

A bug report can enter the backlog with logs, environment details and reproduction steps. An agent can investigate it, reproduce the problem, add a regression test and implement a fix. It then runs the checks and deploys the change to an isolated preview for review.

Production

Agents cannot change production directly or release their own work. The delivery pipeline requires a reviewed merge and explicit release approval from an engineer before deploying the tested software.

Tests describe the expected behavior

Before implementation, we write scenarios that describe what the user or system should be able to do. These become acceptance criteria and, where useful, automated tests.

Unit tests check business rules. Integration tests check how systems connect. End-to-end tests check critical user journeys. Where practical, we add a regression test for each confirmed defect so the same problem fails a check if it returns.

Reviewers use these tests to assess the change. Future developers can use them to check whether their work preserves existing behavior.

Releasing changes

We keep changes small enough to review and run each one through the same build, test and preview process. Engineers remain responsible for merges and releases. Automation handles the repeated checks and deployments after approval.