AI coding agents can generate and revise software, but McKinsey’s 2026 technology outlook warns that producing more code does not equate to delivering better products.
The opportunity for African digital teams lies in verifiable releases, well-defined requirements and affordable compute, not autonomy for its own sake.
Faster Code Exposes Slower Delivery Systems
McKinsey’s Technology Trends Outlook 2026 identifies “01 Agentic software development” as a new trend under its “AI revolution” category.
- It describes large-language-model-based systems that plan, write, test, debug and sometimes deploy code with varying degrees of autonomy.
- The developer’s role moves to defining work, supervising agents and deciding whether outputs meet operational standards.
For African banks, start-ups and public digital teams, that shift could shorten routine development tasks.
However, software delivered to a customer or citizen must still work securely, remain maintainable and integrate with existing systems.
- An apparent saving in drafting time may disappear if testing, documentation and incident response are under-resourced.
This article focuses on the report’s AI revolution section, with emphasis on Agentic software development.
More Code Need Not Ship
McKinsey cites a study in which coding activity rose 180% while shipped releases increased just 30%.
- It also reports that productivity fell after agentic-tool adoption in 30% of companies in its research.
- The numbers challenge the easy assumption that a faster coding assistant translates directly into more useful products.
That gap matters where delivery budgets are tight.
- A team may now draft a feature overnight but still wait on security reviews, unreliable requirements or an old payments interface.
- Automating one stage can move the bottleneck to the next.
- A more useful measure is the time from a defined user need to a secure, maintainable service in production.
Lifecycle Controls Determine Productivity Gains
The report describes a move from real-time prompting toward asynchronous delegation:
- An engineer assigns a task and returns to review code, tests and documentation later.
More autonomous execution means access and security questions become more urgent.
- An agent that can edit a repository or act on a deployment pipeline needs limited permissions, a review trail and a way to stop or reverse changes.
McKinsey argues that the bigger value lies in redesigning the product-development lifecycle, not only automating lines of code.
- Good requirements tell agents what to build; testing and human judgment establish whether it works.
- Existing codebases are harder than new projects because agents must understand dependencies and past decisions.
Institutional knowledge becomes part of the technical infrastructure.
Costs also change.
- Repeated model calls and orchestration turn token use into an operating expense.
- If an agent loops through ambiguous tasks, extra compute can erode savings in staff time.
Technology leaders should measure cost per accepted change, not simply total generated code or the number of employees with access to a tool.
Better Tools Can Extend Local Capability
Well-managed coding agents could help small teams modernise legacy applications, write tests and improve documentation.
- That may be valuable for institutions with essential services and limited engineering capacity.
However, the opportunity requires staff skills, dependable connectivity, secure infrastructure and time for human review.
Developers may also have more room for architecture and product thinking if repetitive implementation is reduced.
- The downside is that less experienced engineers could inherit fragile code they do not understand.
- Training must therefore strengthen debugging, design and security judgement, not assume prompts replace expertise.
For users, the meaningful benefit is faster service delivery without increasing defects or exposure of personal information.
- An online registration system that crashes after launch is not a productivity success because it took fewer hours to code.
This distinction keeps people, not tool activity, at the centre of the technology story.
Budget For Assurance Before Autonomy
Start with bounded, well-documented tasks and measurable objectives.
- Define acceptable test coverage, human approval points and rollback procedures.
- Restrict agent access to the repository and deployment environment; preserve logs showing what changed and why.
- Test for vulnerabilities and regressions before users are affected.
Managers should compare release frequency, time to fix defects, maintainability, and user satisfaction against compute cost.
- A team can pilot multiple tools, but it should expand only when the complete lifecycle is improving.
- For public services, privacy and procurement rules should be built into requirements before an agent is asked to generate code.
Invest in the delivery skills that move working software to production.
McKinsey’s talent analysis highlights a shortage in continuous integration and delivery relative to demand in its dataset.
- African teams should assess their own skills locally rather than applying the report’s principally English-speaking job-posting ratios as continental labour statistics.
Path Forward – Verify What Agents Actually Deliver
The strongest agentic-coding programme is judged by reliable releases and total cost, not lines generated.
Human oversight remains part of engineering productivity.
Build from documented pilots, strengthen testing and give agents only the authority they need.
That approach can expand local capability without outsourcing judgment.
