Skip to content
Français
Account: not signed in, sync available My learning
Select theme
Français

Your time saved must not become our technical debt

Improve this page
16 min read
Your time saved must not become our technical debt

Yesterday, along with colleagues, we were told that we would have to integrate applications generated with AI by the business teams into the information system.

I had nightmares about it last night. In my dream, I had been called while on call. I had to analyse code written in a language I did not master and had not chosen, with unverified dependencies, packages booby-trapped by typosquatting and components left on old versions.

When I woke up, the question was still there: who was going to own these applications once they reached production?

The requirement still needs clarifying. The technical choices, on the other hand, are already made.

The prototype turns critical with no decision to take it on

I understand the enthusiasm. You describe an idea to an AI, an interface appears, a few clicks work. A problem that had been waiting for months seems to have found its answer at last.

Except that this demonstration says nothing about the questions that show up the moment you want to turn it into a service used inside the company. How do users sign in? Who can see which data? Where are the secrets stored? How do you back up, restore, update, diagnose an incident? Who picks the subject up when the person behind the application moves to another role?

Those questions do not go away because the code was produced quickly. They become the workload of the team that agrees to take it over.

"It works on my machine" describes a successful demonstration. It does not describe a service we are ready to run in production.

This drift is also described by Thoughtworks in its Technology Radar entry on AI-accelerated shadow IT. The Radar recommends telling throwaway experiments apart from critical processes, providing controlled sandbox environments and making existing solutions visible. What I take from it above all is this: the move from experiment to durable service has to be organised, rather than left to happen by default.

The technical choices land before the discussion

When an application turns up with esoteric languages and even stranger dependencies, somebody then has to own its maintenance and its security.

A technology missing from our catalogue may well be relevant. It still has to be examined for what it brings and what it will cost us. Do we have the skills to maintain it? Can our tools build it and analyse it? Who will follow its updates? Why add a new stack if a solution we already master answers the need?

When these questions come up after delivery, the discussion starts under extra pressure: the application exists, somebody demonstrated it, users are waiting for it. Going back over its foundations becomes harder.

And the effect compounds. One more application means one more repository, one more environment, more dependencies, more access rights and one more life cycle. Over time, we build up a code estate whose maintenance outgrows the means available.

The cost of generating code tells you nothing about the cost of owning it.

Comprehension debt piles onto the debt we already carry

This is the point that demonstrations usually leave out: the teams that have to take these applications over are not sitting around waiting for work. We already have our own dependencies to update, our ageing components, our defects to fix and our services to make reliable.

We already struggle to pay down that debt. Adding applications designed outside any framework, with no time and no means to take them over, raises the load again. Every handover is paid for by a trade-off: which fix will wait? Which update will be postponed? Which reliability project will be sacrificed?

An application generated quickly does not create the maintenance capacity that goes with it.

And we cannot promise unlimited handovers. Keep asking the same teams to absorb their own debt plus whatever arrives from everywhere else, and you end up burning out the people who still understand the system. For my part, I refuse to let their availability serve as the adjustment variable for every experiment.

Addy Osmani describes another dimension of that load in The 80% Problem in Agentic Coding: comprehension debt. The code is produced, sometimes the tests pass, but those who accept it no longer understand enough about how it works. That post is a field report; its percentages are not a universal measure of what AI can deliver.

I draw a consequence for our organisations: taking an application over also means funding the time needed to understand it, run it and maintain it. A repository handed over is not a transfer of skills.

Who will answer when the application goes down?

In I still care about the code, Birgitta Böckeler suggests looking at generated code through the lens of on-call responsibility: which change would we agree to deploy if we had to personally handle its consequences? She insists in particular on trust in the tests and on the ability to detect problems.

That question puts operations back in the middle of the discussion. During a demonstration, we see the features that work. During an incident, you have to understand what no longer works, track down a change, protect the data and restore the service.

Take a fictional situation: the purchase approval tool stops responding on closing day. Its creator is not available. The team that gets called discovers a framework it does not know, insufficient logs and no verified restore. The application was demonstrated, used, then taken for granted. The ability to troubleshoot it was never organised.

The problem was already there before the outage: nobody had accepted that responsibility along with the skills, the access rights and the time it requires.

At two in the morning, the person who generated the application with AI is not necessarily the one who will get up. It will be the on-call team, carrying the responsibility of restoring a service it sometimes neither chose nor agreed to take on.

I find that transfer of responsibility intolerable when it is imposed. Experimenting does not give anyone the right to commit other people's sleep, time and professional responsibility. If an application is to be covered by the on-call rota, that commitment is discussed, prepared and funded before it goes into production.

A successful demonstration is not a support commitment. Before we talk about going into production, I want to know which team accepts the service, how it monitors it, how it rolls back and what it must be able to restore. Those answers are built with that team; they cannot be imposed on it after delivery.

What I expect from business teams working with AI

The deliverables we have been asking for over the years are precisely where AI could save us time.

I would like to receive a description of the problem, representative examples, the rules that must not be broken and expected results we can verify. The business side holds knowledge that neither the developers nor the AI can invent: what actually happens in their activity, including when things go wrong.

Take a fictional case: a tool for approving purchase requests. "We need a form and an Approve button" leaves almost everything still to be decided. Who approves? Above which amount? What happens if the manager is away? Can a request be modified after approval? Does the history of a rejection have to be kept?

Here is the kind of work I would suggest doing with AI:

From my notes, help me describe the purchase request approval process. Identify the actors, the business rules, the exceptions and the open questions. Propose verifiable acceptance criteria. Do not invent any rule: explicitly flag the decisions that remain to be made. Do not generate any code.

The output then has to be reviewed and corrected by the business side. A well-written document can still contain a wrong rule. The point is to make the ambiguities visible and to make the discussion easier.

For instance, once the rule is confirmed, a criterion could become:

A request above the threshold allowed for a manager cannot be approved by that manager. The attempt is rejected and the request keeps its previous state.

We can discuss that rule, derive the access rights it requires and build a test from it. That is a deliverable that moves the project forward.

I am not asking for a hundred-page specification frozen before the first conversation. I want examples precise enough to start together, then to be corrected as we learn. Business acceptance criteria describe the expected result; the technical teams build the tests that verify the implementation. The two are worked on together.

AI can help prepare that discussion. It must not turn the business side's grey areas into implicit decisions inside the code.

We generate code with AI too

I use AI to produce code. There is nothing in my point that calls for turning back, and vibe coding (in French) has its place when you know what you are doing with it.

But I want that generation to start from the validated requirement and from the constraints of the system the software is going to live in: identity, security, architecture, exchanges with existing services, data, deployment and operations.

In Agentic Engineering, Martin Fowler distinguishes supervised generation of code from a practice where you stop looking at what was produced. The human remains responsible for the behaviour and the structure of the software. That matches my own requirement: using AI does not excuse you from being able to explain and verify what you ship.

Those requirements have to be available to the agents: project instructions, skills, repository templates and architecture decisions. An agent cannot comply with an internal convention it was never given.

That is not enough. Writing "comply with our security requirements" in a file proves nothing. You have to examine the code, test the behaviours, check the dependencies and verify the deployed configuration. The rules that matter must become reproducible checks whenever that is possible. It is also what the DevOps anti-patterns describe: automation that nobody reviews is not automation, it is a problem deferred.

Simon Willison points out in Vibe engineering that agents benefit from already solid practices: automated tests, documentation, version control, reviews and continuous integration. In other words, putting an agent in front of a repository does not replace the work on its development environment.

The NIST Secure Software Development Framework gives that approach a foothold: define the security requirements and build secure development practices into the software life cycle. The framework I am defending here for splitting the work with the business teams remains my own proposal for organising it.

A prototype must not commit production by default

A mock-up can be useful to explain an interaction or to surface a misunderstood requirement. But what is being shown, and what it commits us to, has to be named.

To my mind, a business prototype remains a discussion aid in an authorised environment, with fictional data. It does not become a production application because it convinced a meeting. Its code can be assessed; taking it over must not be treated as a given.

The decision to industrialise comes with an owner, a scope, a technical analysis and a maintenance capacity. It may lead to reusing part of the prototype, to rewriting it or to picking an existing service. The demonstration helps us understand the need; it must not decide the solution on its own.

The framework must also make the right path practicable

The technical teams carry a responsibility in this situation. If getting a requirement examined takes months, people will look for a way to move forward. A ban with no accessible alternative will not settle that frustration.

So what I am defending is a simple framework, announced before development starts:

StageWhat I want to obtain
Stating the requirementA concrete problem, identified users, examples and acceptance criteria validated by the business side.
Choosing the solutionA check of existing services, of the data involved and of the integration constraints.
DevelopmentA technology stack somebody owns, the information system requirements made available to the agents, and checks run on the result.
Going liveA maintenance owner, controlled access rights, a reproducible deployment and verified operating procedures.

That framework has to be proportionate. A local tool handling fictional data does not call for the same scrutiny as a shared service processing sensitive information. But that distinction must be explicit, not discovered after the application has spread. It is the same trade-off as the one behind security trade-offs: a rule too heavy for its risk gets worked around.

The business teams must know how to get help. The technical teams must be able to explain their constraints and offer a usable path. And every new application must have somebody to own it for the long run.

Time saved has to be measured all the way to operations

What I refuse is for a fast generation of code to become an obligation to take over for other teams. Before adding an application, we have to be able to answer one question: what capacity do we actually have to maintain it, when the existing estate already demands work?

Without an answer, we have not demonstrated a collective gain. We have shifted the load. The prototype became a service with no explicit decision, the code grew without sufficient understanding, and the incidents found themselves an on-call team by default. Those are the three drifts our framework has to prevent.

AI already gives us a way to prepare projects better: making requirements discussable, spelling out the exceptions, building acceptance criteria and producing code inside a known framework. Let us use that capacity before adding an application to the company's estate.

Your time saved must not become our technical debt.

And if tomorrow the prices, the quotas or the products of our AI vendors change, will we still be able to understand, maintain and run our applications?

Sources and further reading

These texts feed the reflection; the starting observation and the organisational choices proposed in this post remain mine.