What happens after the code is generated
AI has changed what a development budget can buy. When an initial implementation can be generated in minutes, more of an engagement can go toward useful functionality, integrations and improvements that previously fell outside the scope.
It has not changed evenly. Google's 2025 DORA research found AI adoption associated with higher delivery throughput and lower delivery stability at the same time. More gets shipped, and more breaks. Which of the two dominates is largely settled after the code is generated.
That raises a reasonable hiring question: how much senior development experience do you still need?
From writing every line to directing the implementation
The answer starts with what happens after the code is generated. Someone needs to establish that it solves the right problem, works under real conditions and fits a solution the business can keep building on. That responsibility is becoming a larger part of a senior developer's working day.
In my own work, the shift has been from writing code manually, to continuously reviewing AI-generated code, to directing larger changes and checking how the changes work together, both on its own, and as part of a larger picture.
AI can produce code faster than I could type it. That changes where I spend my time: clarifying requirements, giving the implementation direction, reviewing decisions, testing behavior and making sure changes belong in the right part of the solution.
Architecture and testing have always been senior responsibilities. What has changed is the balance of the work. With less time spent producing familiar code, more attention can go toward the decisions that determine whether a feature will remain useful and maintainable.
That includes rejecting a working implementation when it creates unnecessary dependencies, duplicates existing logic or makes the next change harder.
A working feature is only the first test
Take a customer registration flow connected to a CRM.
AI can generate the form, validation and integration quickly. In a demonstration, the customer submits their details and a record appears in the CRM. The feature works.
But what happens if the CRM is unavailable? If the customer submits twice? If another application needs the same registration process next month?
Those questions affect both behavior and architecture. The business rules need a clear home. The integration needs sensible failure handling. Shared logic should be reusable without copying it into another page.
An implementation that ignores those decisions may still pass its first demonstration. The cost arrives later, when a small change requires edits in several places or another developer has to untangle the original solution before adding anything.
Senior judgment helps prevent today's delivery speed from becoming tomorrow's maintenance bill. It also keeps the solution proportionate: a straightforward feature should not become an elaborate framework for hypothetical requirements.
What the same budget can buy
When implementation takes less time and the result is sound, the same budget can cover more delivered scope.
That might mean connecting another business system, improving a customer journey or completing an internal tool that previously stopped at a prototype. It can also mean making a feature ready for production within a budget that previously covered only the basic functionality.
The gains depend on the work and the environment, and they are not automatic. That is what the stability half of the DORA finding describes: the report's own conclusion points at the engineering practices around the tools – testing, feedback loops and architecture – rather than at the tools themselves.
There is also a measurement problem worth knowing about. In a randomized trial published by METR in July 2025, 16 experienced developers worked through 246 real issues in repositories they knew well. With AI tools allowed they took 19% longer – and afterwards still believed they had been 20% faster. The authors are explicit that this does not generalize to all development work. What it does show is that an impression of speed is not a measurement.
For a hiring manager, that makes the useful measure reliable functionality delivered within budget, including the effort needed to maintain it. Code volume and self-reported velocity tell only part of the story.
The commercial value of an experienced developer is bringing requirements, implementation and validation together so that faster production becomes a usable result.
What to look for when hiring
This changes how I would assess development capacity.
Ask a candidate to walk through a generated implementation and explain what they would keep, change or reject. Can they connect their decisions to the business requirement? Recognize existing functionality that should be reused? Explain how they would test the result?
Look for breadth, too. A feature can touch the interface, application logic, database, integration and deployment configuration. Someone taking ownership needs to understand those connections and recognize when specialist input is required.
Finally, look for responsibility through delivery. Reviewing code is part of the work. So are resolving unclear requirements, correcting the implementation and getting it safely into production.
One thing this does not change: it is still worth hiring junior developers. But juniors working with AI need more review capacity per head rather than less, and that capacity comes out of the same senior people. Plan for it rather than discovering it.
These are practical ways to assess whether someone can turn AI-assisted development into dependable progress.
A reason to revisit the project you postponed
If an integration, customer portal or internal tool previously felt too expensive, it may deserve another look.
Start with one clear business problem and a focused first release. Senior involvement at that stage helps establish the responsibilities and conventions that later development will follow. Those decisions are easier to make before features accumulate around them.
AI can help accelerate the implementation, while an experienced developer keeps the scope realistic and the foundation ready for the next useful addition.
Put that capacity to work
I have worked in .NET since 2008 and with Umbraco since 2013, with a background working alongside marketing, sales and business decision-makers.
For businesses, I can take a requirement from initial discussion through implementation, release and ongoing improvement. For agencies, I bring senior delivery capacity and technical ownership alongside your existing team. For product teams, I can take responsibility for development work with attention to both the current release and what comes next.
If you have a project in mind or a backlog that needs movement, get in touch with the business goal, the support you need and your preferred start date. We can discuss a practical scope and my availability.
For new Umbraco projects, my platform can also provide an established starting point, leaving more of the budget for work specific to your business.
Figures checked against the primary sources on September 15, 2026: Google's 2025 DORA State of AI-assisted Software Development report and METR's July 2025 randomized trial. Both are worth reading in full, including the limitations their authors state.