Skip to main content

AI in the software development lifecycle

What this page covers

How AI is used at every stage of software development, what the tools read of a company's code and data, who checks what they produce and what we measure.

AI reached the whole development process in sixteen months, one stage at a time. Each stage names who or what checks the result before the work moves on. The rules are written down. The effect is measured on review time, builds and incidents.

Every stage has a check

Each of the eight stages pairs an agent's work with a named check.

  • Requirements and specification

    An agent weighs feasibility against the requirements in place and writes the specification and the technical plan. The product lead decides what reaches the backlog. Nothing is coded before the team leader approves.

  • Design and development

    An agent proposes the architecture, reads the approved design from Figma and turns it into versioned tokens, then writes code under the project's rules. The team leader approves it.

  • Review and test

    An agent reviews every pull request and traces a reported bug back to the code behind it. A major finding stops the merge. The tester confirms the bug before a ticket is opened.

  • Release and documentation

    Before a cluster upgrade an agent lists the breaking changes to handle. It keeps the documents in step with the code, and the technical team checks the impacts.

Access cleared for defensive use

Our access to the models is Defense Access, granted under the CVP programme and reserved to organisations doing defensive security work. Every model is available at that level, Mythos and Opus 5.5 included, and agents read code and configuration for vulnerabilities, citing file and line. Offensive use stays blocked here too. Work on a system needs a written authorisation. One rule follows from the level: no credential enters a session. Scripts read keys when they run. A document names the file holding a setting, never its value.

One tool, and the rules around it

The team works with one tool, Claude Code, and what surrounds it is written down. What runs inside delivered software, the AI Act and the architecture behind its agentic parts, is a different subject.

  • Configured project by project

    Each repository carries the architecture, the commands and the conventions in a file updated with the code. The project declares what the agent may read and which commands it may run.

  • It reads the project's systems

    Standard connectors reach the issue tracker, the repositories, the documentation, error monitoring, the cluster and the design tool, each with its own credentials.

  • One rule book, with an owner

    The rules are owned by the CTO, mapped to the controls of the ISO/IEC 27001-certified management system and signed by everyone with access. A company's own AI policy enters them first.

Generated code is reviewed like any other

Every pull request goes through an automatic review that applies the project's written conventions. A critical or major finding fails the pipeline and the merge stops. The same review runs locally, so a developer clears the findings first. Human approval is still required and the developer decides task by task whether to use the agent: in one framework migration agents produced around 40% of the commits in the busiest month. The code belongs to the company that commissioned it.

The system in use writes the test

On a system already running, what it does today is the criterion for accepting every new part.

  • From the system to the rules

    AI tools read the code, the data and the real traffic. Out of them come the rules in force, the acceptance criteria and the tests that fix today's behaviour.

  • Also without the source code

    Where the source is gone, behaviour is observed from the outside: calls between components, the database, batch files, screens. Recorded traffic is replayed against the new part.

  • What the new part has to pass

    Those tests are the acceptance criteria. Old and new run for a while on the same inputs, so a difference shows up early.

Findings are checked before they are used

An agent's first answer is a hypothesis. Each one faces a check before anyone acts.

  • A second agent attacks the plan

    It re-rates every risk: security, backwards compatibility, performance and the fit with systems in production. In one refactoring that review raised a licence risk from low to critical.

  • Causes with a reference that holds

    Sixty-eight agents worked in parallel over the history of defects, crossing tickets with the history of the code. Every commit cited was checked and every classification carries its confidence.

  • Measurements before conclusions

    In operations an agent reads the recorded error and traces it to the code. Performance work starts from measured traces. A cause holds only when test evidence confirms it.

What we measure, and what comes next

Speed early in the cycle can cost later, so the measures sit downstream. We track the coverage of the tests derived from a system in use and the differences found while old and new run together. Review time, builds that succeed and incidents in production are read over the same period, before and after. Two steps are next, not done: interface tests written and run by agents, and agents that read the logs at intervals and propose changes.

INSIGHTS

5.5%

Lower build success rate

Three field experiments with 4,867 developers measured more pull requests per week and a build success rate 5.53% lower. Source: Cui and others, Management Science, 2025.

Contact us to validate the technical feasibility,

business impact and build your business case together.

CONTACT US