AI Is Writing the Code, but Who Is Accountable When It Fails?

For decades, accountability in software development has been relatively clear.

The developer writes the code. The team reviews it. Tests verify that it works. The organization decides whether the software is ready to be deployed to production.

But AI is changing one of the most fundamental links in this process.

Today, a coding agent is no longer limited to suggesting a few lines of code.

It can analyze a repository, identify a problem, modify multiple files, build a feature, run tests, and propose an almost complete implementation.

According to Anthropic’s The 2026 State of AI Agents report, more than 9 in 10 surveyed organizations use AI to assist with coding. 86% use coding agents for code that goes into production, while 42% trust these agents to lead development work, with humans continuing to review the code and define the strategy.

This creates a question that the software industry will increasingly need to address:

If AI writes most of the code, who is accountable when that code fails?

From “AI Helped Me” to “AI Implemented It”

In the early stages of AI-assisted coding, the division of responsibility was simpler.

The developer wrote the code, while AI suggested a function, completed a few lines, or explained an error.

Decision-making and implementation remained primarily human.

Coding agents are changing this relationship.

A developer can give an agent a high-level objective and allow it to determine part of the implementation approach on its own.

Anthropic’s study of approximately 400,000 Claude Code sessions shows precisely this division: humans tend to make more decisions about what should be done, while AI makes more decisions about how it should be done.

In this model, the developer is not necessarily the author of every line of code.

But the developer remains part of the process that determines whether that code should be accepted.

The Author of the Code and the Person Accountable for It Are Not Necessarily the Same

An important distinction needs to be made here.

Who generated the code?

and

Who is accountable for deploying it to production?

are two different questions.

A coding agent may generate the implementation.

But the organization decides which AI tools are used, what access they have, which standards the code must meet, and at what point human approval is required.

Therefore, the use of AI should not create an accountability gap.

On the contrary, it requires accountability to be defined even more clearly.

“AI Wrote It” Cannot Become a Mechanism for Transferring Accountability

Imagine a coding agent creating a new feature.

The tests pass.

The code looks clean.

The developer approves it, and the change goes into production.

Later, a serious problem is discovered.

In a traditional model, the team can analyze the technical decisions that led to the error and the code review process that failed to identify it.

In an AI-driven workflow, a new response may emerge:

“AI wrote that part.”

But this does not solve the problem.

If an organization has chosen to use AI to implement software, it must also build the processes required to verify its output.

AI may change how code is produced.

It should not eliminate accountability for how that code is verified and used.

Human-in-the-Loop Is Taking on a New Meaning

According to Anthropic’s report, 42% of organizations say they trust coding agents to lead development while humans remain involved in reviewing code and defining strategy.

This phrase — human-in-the-loop — is becoming increasingly important.

But simply having a human involved in the process is not enough.

If AI generates thousands of lines of code and a developer simply clicks “Approve,” human oversight technically exists, but it may not meaningfully exist in practice.

Therefore, the question should not only be:

“Did a human approve it?”

It should be:

“Did that person have the information, time, and expertise required to properly evaluate the change?”

The More Code AI Produces, the Harder It Becomes to Review Everything

AI creates a new paradox for software teams.

Coding agents can significantly increase the speed at which code is produced.

But the speed of human code review does not automatically increase at the same rate.

If a team previously produced ten changes per day and AI now helps it produce many more, manually reviewing every change with the same level of depth becomes increasingly difficult.

Anthropic anticipates exactly this kind of transformation: human oversight may gradually shift from reviewing every output to focusing on cases where human judgment is genuinely necessary.

This means that the system itself must become better at identifying risk.

AI Can Review AI, but Accountability Does Not Disappear

One emerging solution is to use AI to review the output of other AI systems.

One agent can write the code.

Another can review it.

A security system can search for vulnerabilities.

Automated tests can verify behavior.

Another mechanism can flag only high-risk changes for a developer to inspect.

This can make oversight far more scalable.

But it also creates another question:

If AI writes the code and another AI approves it, who reviews the review system?

Ultimately, there must be a level at which accountability belongs to the organization and the people who define the rules governing the system.

Accountability Is Shifting From the Line of Code to the Development System

This may be one of the most important changes AI brings to software engineering.

In the traditional model, the developer was very close to every line of code they produced.

In a model built around coding agents, the developer may be further removed from direct implementation.

Their responsibility shifts toward designing the process:

What can be delegated to AI?

What should be checked automatically?

Which changes require human code review?

When should the agent stop and ask for help?

Which tests must pass before a change is accepted?

Which parts of the system are considered too critical to be fully delegated to an agent?

These are becoming questions of software architecture and engineering governance.

Human Expertise Is Not Becoming Less Important

It may seem that the better AI becomes at writing code, the less technical expertise developers will need.

Anthropic’s data suggests a more complex picture.

In its analysis of approximately 400,000 Claude Code sessions, users with greater expertise in the relevant domain were more likely to complete tasks successfully.

This makes sense.

To review an implementation, you need to understand how the system should behave.

To identify a poor architectural decision, you need to understand the architecture.

And to know when not to trust an AI-generated result, you need the expertise required to challenge it.

AI may therefore reduce the amount of code a developer writes manually, while increasing the importance of technical judgment.

Traceability Will Become as Important as Code Review

In a system where AI participates in implementation, teams need to understand how a change was created.

Which agent proposed it?

What instructions did it receive?

Which tools did it use?

What tests did it run?

Which developer reviewed it?

Which automated checks did it pass?

This creates a new form of software traceability.

It is no longer enough to know only what changed in the code.

Increasingly, we may also need to know how and by whom the decisions that produced that change were made.

From Code Ownership to AI Governance

Many software teams already use the concept of code ownership.

A team or developer is responsible for a specific part of the system.

Coding agents should not eliminate this model.

They may make it even more important.

A repository may contain thousands of lines of AI-generated code, but there must still be human ownership of the system.

Someone must define the standards.

Someone must establish the boundaries of autonomy.

Someone must analyze incidents.

And someone must have the authority to say that a change produced by AI should not be deployed to production.

AI Code Accountability Is Becoming Part of Software Architecture

For Soft&Solution Group, the question of who wrote a particular line of code will gradually become less important than the question of how that code was verified before becoming part of the system.

Organizations using coding agents need to design not only how AI produces code, but also how that code is tested, reviewed, approved, and traced.

This means accountability cannot be a discussion that begins only after an incident occurs.

It must be built into the architecture of the development process from the beginning.

As Ermal Beqiri, founder of Soft&Solution Group, puts it:

“AI can take on an increasing share of implementation, but accountability cannot be delegated to a model. If an organization decides to trust AI with writing code, it must also build the mechanisms that define who reviews it, who approves it, and who is accountable for the outcome. Technical autonomy must always be accompanied by clear human accountability.”

AI is changing the authorship of software.

An increasing share of implementation may be produced by systems that are not human.

But that does not mean accountability should become unclear.

Quite the opposite.

The more autonomous a coding agent becomes, the more clearly its boundaries, verification process, and human ownership of the outcome must be defined.

In the age of coding agents, the question will no longer simply be:

“Who wrote this code?”

The more important question will be:

“Who decided that this code was good enough to use?”