Figures from inside a large technology company are rare, and so it is worth taking a close look at two pieces of information that Google engineer Haydn Belfield has made public.First: more than 75 per cent of the production code in the company is written by AI.Second: 88 per cent of changes still require human control.
Both figures belong together.Taken on their own, the first sounds like the replacement of development work, the second like stagnation.Together they describe something more sober: a division of labour in which the writing of code is largely automated, but the decision about the what and the whether remains with humans.
Production code is not the same as finished software
Production code means the code that is actually used in live operation – as opposed to experiments, prototypes or throwaway scripts.The fact that a large part of it is produced by machine shows how far code generation now carries.
However, the share says nothing about how much work goes into formulating the task, checking the result and correcting it.That is precisely what the second figure points to.If almost nine out of ten changes require human control, then the AI is a very productive executor, not an independent developer.
For project managers, this distinction is central.The time saving arises in typing, in generating variants, in filling in known patterns.It does not arise automatically where the actual complexity of a project lies: in the coordination of requirements, in architecture decisions, in the question of which solution will still be maintainable in five years.
No acceleration of research through research AI
Belfield also commented on a further expectation: that AI noticeably accelerates AI research itself.At Deepmind, no such acceleration is measurable.An internal benchmark, the General Capability Index, shows steady growth – that is, a continuous improvement in capabilities, but no jump in pace.
From this he concludes that a self-improving AI remains a thing of the future for now.This means a system that develops its own successors and thereby becomes better faster and faster.The idea shapes many scenarios for the coming years – but according to this assessment, there is currently no evidence that it has already occurred.
For planning in companies, this is a reassuring message.Anyone designing a platform today does not have to expect the technological foundation to race away unpredictably within a few months.The improvements come, but they come at a pace that can be mapped in roadmaps.
What this means for practice in web projects
The figures cannot be transferred one-to-one.Google works with its own infrastructure, its own models and a very large, well-documented codebase – conditions that do not exist in a mid-sized environment.The direction of the statement is nevertheless transferable.
- Code generation is everyday practice, not future technology. Anyone who does not yet use it in web projects is wasting time on routine tasks: standard components, tests, migration steps, recurring configurations.
- Review remains the bottleneck. If significantly more code is produced, significantly more code must be reviewed.Teams that do not let their review capacity grow accordingly are merely shifting the problem to a later point.
- Responsibility cannot be delegated. Security, data protection, accessibility and performance are properties that someone must check and take responsibility for.A generated result is a proposal, not an approval.
- Keep expectations realistic. A doubling of development speed across the whole project cannot be derived from these figures.What is accelerated is a sub-step, not the entire value chain.
Quality assurance becomes a core competence
If writing code becomes cheaper, the relative value of all surrounding activities rises: clean requirements, understandable interfaces, automated tests, traceable documentation.These tasks have always been important; their absence simply became apparent more slowly.
With generated code, it becomes apparent more quickly.A model orientates itself towards what it finds in the existing codebase and in the brief.If the structure is unclear, many lines of unclear structure quickly emerge.Order in the codebase is therefore no longer an end in itself, but the prerequisite for automation to deliver usable results at all.
In practice this means: defined coding standards, a binding review process with clear responsibilities and a test strategy that makes regressions – that is, the unintentional reappearance of old errors – visible early.These building blocks determine whether code generation brings speed or merely technical debt.
Assessment
For web and software projects, the Google figures are above all a calibration aid: AI-supported development is productive enough to be firmly planned in, and at the same time far from taking over control and responsibility.Anyone aligning budgets and schedules with this should factor in the saving in implementation – and at the same time provide for more effort on review and quality assurance.
The pace of the models is growing steadily, but without a leap; so there remains time to adapt processes and team structures in an orderly way, instead of restructuring them under pressure.