AI makes software development faster. Who’s responsible for the release?
November 17, 2026
AI arms developers with powerful new tools every single day. They make it easier to translate ideas into working code. Development teams can generate features, tests, integrations, and documentation much faster than in the pre-AI era.
Yet while software generation is becoming more and more automated, we can’t say the same about confidence in software delivery. And that matters a lot.
While many engineering organizations get stuck on how much faster developers can build with AI or how many hours it can save (and these are indeed good points), they fail to see a more fundamental change AI brings.
Before artificial intelligence became mainstream, the traditional constraint was producing software. Now, software verification is the new constraint. Basically, generating software is getting faster and easier. Knowing for sure that this software aligns with business intent, is correct, reliable, and can be maintained over time is much harder.
This way, teams now struggle less with crafting software and more with proving that customers can trust it.
So, who’s responsible for the release when AI writes the code? People are, just like before. Yes, AI can generate code. Humans – developers and entire organizations – still own quality and business outcomes. What changes is how much evidence they need before they can say, “Yes, we can ship this.”
Why is verifying AI-generated code harder than writing it?
Historically, software organizations were limited by how much their teams could build. Designing features, implementing, reviewing, testing, releasing – all the ingredients of software delivery – took time. They depended directly on how quickly teams could write and maintain code.
With AI, the situation is different now.
It takes minutes for a developer to generate hundreds of lines of code. AI can quickly transform requirements into entire workflows. Teams can implement reusable patterns almost instantly. But with all that in place, development teams are discovering that it gets tougher to validate code than to generate it.
The issue is especially visible in Business Central projects. In enterprise systems like this, making changes in one part of the solution echoes in related integrations and elements.
“What seems a simple customization at first sight may affect financial posting and inventory valuation. It can impact warehouse processes, manufacturing planning, reporting, and so many other Business Central functionalities. With AI, teams may implement changes faster. But AI does not automatically grasp what these changes may bring to business.”
- Oleksandr Klymenko, Head of Engineering at Global Mediator
In practice, it means the problem changes. But not because AI creates bad software. It’s because AI creates software so fast that most teams’ verification activities can’t keep up. According to GitLab’s 2026 AI Accountability Report, 85% of respondents agree that AI has moved the bottleneck from writing code to reviewing and validating it.
Agentic development makes teams realize that software generation was never the goal. The real goal has always been delivering reliable, trustworthy outcomes for a business.
In some cases, generating more code means creating more risk rather than value.
Why can more AI-generated code mean more risk?
Many organizations tend to believe that AI-generated software somehow carries less responsibility because it was not written entirely by humans.
From our experience, it’s a wrong impression.
When implementation gets faster, organizations naturally implement more changes. Making changes often means releasing often as well. In turn, this implies more experiments and opportunities to improve.
But it also means more opportunities for hidden defects and incorrect assumptions. It may also bring architectural inconsistencies and side effects no one ever planned for.
An example: a Business Central implementation with multiple custom extensions and integrations. An AI agent might successfully generate a new approval workflow in minutes. The code may compile, and basic testing may pass. Overall, the feature may appear complete.
But some critical questions are still open.
How does the change interact with existing approval flows?
What happens when a flow relies on delegated approvals?
How does it affect audit requirements?
Does it behave correctly across all companies, environments, and user roles?
To find the answers to the questions above, organizations should care more about verification than coding itself. The faster they can generate code, the stronger their ability to validate must become.
Delivery speed should not exceed delivery control.
What is specification-driven development, and why does it matter with AI?
Specification-driven development (SDD) is an approach where teams agree on certain rules before implementation starts. These often include things like acceptance criteria, edge cases, constraints, and more. Both people and AI then use these rules as the single source of truth for development.
With AI-generated code, clear specifications are more important than ever.
For decades, a mixture of requirements documents, meetings, tribal knowledge, and developer experience was quite enough to build software. Through rounds of discussions and interpretations, human developers could often avoid ambiguity.
The problem with AI is that when you feed it poor information (incomplete, inconsistent, or unclear requirements), it does exactly what it always has: it generates output based on what you provided.
That’s why specification-driven development is becoming so important.
“A good specification defines business expectations and acceptance criteria. It sets scenarios for workflows, edge cases, constraints, and quality requirements. A good specification prepares for a successful release before even the implementation starts.”
- Nicolai Krarup, COO at Global Mediator
Talking about Business Central, this may include defining how the system will calculate discounts and route approvals, how it will handle inventory transactions, or exchange data with external systems.
Once these expectations are put in black and white, humans and AI can cooperate safely. If specifications are clearly set, AI doesn’t generate assumptions anymore. It generates implementations.
That difference matters more and more as development gets more agentic
Moving from testing to continuous verification
As a rule, quality was often tied to testing that happened after development was mainly complete.
The approach changed over time. Now engineering environments need a different mindset. It takes less time for organizations to deliver software. They can’t postpone quality till the end of the lifecycle. Quality is now an indivisible part of the entire system, turning test execution into continuous verification. It covers specifications, automated validation, quality gates, and architecture reviews. It also deals with acceptance criteria, release evidence, and risk assessment.
What’s more, verification helps preserve professional engineering judgment. Human judgment. As MIT Sloan Management Review puts it, the defining challenge of responsible AI is designing systems that preserve human judgment when and where it counts. If teams rely exclusively on output that AI generates without checking or questioning it, they eventually face the risk of losing the experience they need to notice issues when they pop up. This makes human oversight vital when dealing with high-risk decisions on solution architecture and release readiness.
It takes more than simply making sure that a Business Central solution is technically correct. The team may verify financial workflows, compliance requirements, and approval paths, as well as integration behavior, reporting accuracy, user permissions, and more.
Verification is not a box-ticking exercise. It aims to make sure the business-critical process behaves as expected and the organization has enough evidence to trust the result.
What is release confidence?
Release confidence is certainty that relies on evidence. It’s confidence that a new version can safely go to production. In the end, it’s what you really deliver.
We’ve tracked things like test counts, coverage, automation rates, pass rates for years. And it made sense. Back then, writing the software was the hard part. Classic metrics are still useful, but they don’t really answer the question: can we ship what we’ve built safely?
You need release confidence to know that for sure.
Confidence relies on evidence. Evidence is based on verification activities run at every stage of the delivery.
Before deploying a new version, organizations should be able to explain what changed and which critical workflows they validated. Which risks still remain, and why the release is considered acceptable.
In a Business Central environment, this could mean demonstrating that core features (order processing, invoicing, inventory transactions, financial reconciliation) and external integrations still work correctly after adding a custom feature on top.
Guessing games don’t support strong release decisions. Evidence does.
Who is accountable when AI writes the code?
There are many myths around AI. One of them is that responsibility for the output somehow transfers from humans to the technology.
Well, it doesn’t.
AI does generate code and suggests solutions. It can execute tasks and help make certain engineering activities more efficient. But it can’t own outcomes. Developers are still responsible for implementation quality. Engineering leaders are still responsible for delivery quality. Organizations are still responsible for business outcomes.
This principle of AI accountability matters even more as AI adoption goes global. Software development relies more on agent autonomy. It makes governance, oversight, and verification more crucial.
Where is quality engineering heading?
The future of software delivery is not about picking sides: humans or AI agents. The agenda is to create engineering systems where both sides can cooperate effectively.
With that in mind, quality engineering grabs the spotlight. Testing software after it was built is no longer enough. The point is to organize work in a way that allows teams to ship changes safely, again and again, and really trust the solutions they’re delivering.
AI-assisted development and specification-driven development are turning into common practice. But that doesn’t mean that generating more code and doing it faster makes an organization succeed. Instead, those putting effective continuous verification in place, treating AI accountability seriously, and reaching release confidence will come out ahead.
AI tools turn writing code into the easy part of the equation. Earning the confidence to ship it is becoming the hard one.