A large share of engineering time goes not on new code but on understanding old software, often with documentation incomplete or outdated. This film shows how GreenCode aims to take that overhead off a development team by mapping the code, writing missing tests and documentation, working through analysis findings and benchmarking. Developers then review changes instead of rewriting them.
Read the full page Watch on YouTube
A large share of engineering time goes not on new code but on understanding old software, working out what a change will break, writing tests that should already exist, and reviewing edits nobody documented. The starting point is familiar: systems often spanning millions of lines built over many years, with documentation incomplete or outdated, and source code the only reliable reference. GreenCode does not try to replace the copilot in the IDE. It aims to take on the overhead around development instead: comprehension, artefact generation, testing, benchmarking and review.
The pipeline is designed to take four jobs off the development team. First it maps the codebase, reading it line by line into a searchable index with a bill of materials, and identifying interfaces and endpoints. Next it generates artefacts: where unit tests, in-code comments or external documentation are missing, generative AI creates them. Then it remediates automatically, working through the static analysis findings and flagging deficient dependencies as it goes. Finally it benchmarks without hand-written scripts where the system allows, deriving load tests from the indexed endpoints. The output is an optimisation branch, so developers review instead of rewrite.
Studies have found generated documentation on a par with what people write for readability, relevance and completeness, and in practice generated tests go into the standard frameworks teams already use. So what comes back is a mapped, documented and tested codebase, a stream of reviewable pull requests with annotated commits, stakeholder reports, and bespoke training material derived from the team's own code, so the knowledge stays with the team.
The risks are real, too. Copilot-style tools have led to siloed practices that create new forms of AI-induced technical debt at team level. Single-pass generation is often outperformed by iterative, workflow-based approaches that combine translation, test writing, error correction and call-graph analysis. And the usual benchmarks ignore energy, so tools can appear successful while producing inefficient code. GreenCode takes the iterative route, with measurement and regression checks between steps, and a combined score of quality issues, security flaws and error rate that must not rise. The project intends to measure this rather than assume it. Tools that port legacy code to a modern language are planned for enterprise software in the project's use cases, and industrial partners expect the pipeline to speed up legacy migrations. The use cases define the measures: developer productivity, time to onboard new developers, and the rate at which test cases are written. Reach out to us with the codebase that is slowing your team down, and we will help you work out how much of that overhead GreenCode could take off them.
Benefit film
When an organisation buys a dishwasher it is told how much electricity the machine uses; when it buys software it is told nothing at all.
Benefit film
The world produced 62 million tonnes of electronic waste in 2022, and under a quarter of it was documented as formally collected and recycled.
Benefit film
If your organisation reports under the EU's corporate sustainability directive, the electricity your software uses is already in the numbers you sign off, but usually…
