You asked for a quote for an internal tool. You received two. One announces €4,000 in three weeks, the other €18,000 in ten weeks. Both say they develop software with AI. You are looking for where the gap comes from, and nobody explains it clearly. That is normal: the two quotes are not talking about the same object. One sells the writing of code, the other sells a tool that is still running in two years, with your data in it and your teams using it every morning.
This article is not a forecast about the future of the profession. It is a reading grid for a business owner who has to choose between two proposals.
What AI really changes when you develop software with AI
Let us start with honesty: the change is real. We use these tools every day, and we would not go back. But the gain is concentrated on one part of the work, not on all of it.
What it speeds up
Writing code, first. What used to take two days of typing often takes a few hours. Repetitive tasks, next: producing twenty screens that look alike, hooking up an export, generating tests. Documentation, finally, which was traditionally the first item sacrificed in rushed projects.
It also speeds up the prototype. Showing a clickable mock-up in two days rather than two weeks changes the conversation with your teams. You correct before building, not after.
What it does not speed up
Understanding your business. A coding agent does not know that your salespeople call "file" what accounting calls "job", or why the price changes when the customer is a former employee. That information is written nowhere. It comes out of interviews.
Deciding what we do not do. That is the real work of design. On an initial request, half the functions asked for are useful to nobody after six months. Arbitrating is an economic choice, not a technical task. No agent will do it for you, because it knows neither your cash position nor your priorities for the year.
Taking over what exists. Your data lives in Excel files with three duplicated columns, free-format dates and customer names written four ways. Cleaning and migration are often the heaviest item in a project. AI helps write the scripts. It does not decide which version of the customer "Dupont / DUPONT SA / Dupond" is the right one.
Getting the tool adopted. An application nobody opens costs exactly its price, less zero benefit. Training, support for the three weeks after go-live, the retaking of habits: that is human time, and it does not go down.
Answering for it in two years. When a bug blocks invoicing on a Friday evening, you need someone who understands the code, not someone who asks a machine to regenerate it.
The figures going around, and what they measure
Two figures keep coming up at the moment. They deserve to be set side by side.
| What you read | The source | What it really measures |
|---|---|---|
| AI reduces development costs by 10 to 25% | GoodFirms, 2026 survey | A whole project, scoping and acceptance included |
| In 45% of cases, a model given the choice between a safe method and an unsafe one picks the unsafe one | Veracode, GenAI Code Security Report 2025, 80 tasks across more than 100 models | A model's raw code, before any human review. Not the code of a delivered project |
| "Software that cost €50,000 in 2023 costs €5,000 today" | Sales pitch heard on the market | Nothing verifiable, and probably not the same perimeter |
Hold on to the first. Ten to twenty-five per cent is significant. On a €20,000 project, that is €2,000 to €5,000 of real savings. It is not a division by ten.
When someone announces a division by ten, two explanations are possible. Either the €50,000 reference project was badly sold in the first place. Or the new €5,000 project contains no scoping, no data migration, no acceptance testing and no follow-up. It is a prototype delivered as a finished product. It sometimes works. It shows mostly after four months, when the first special case breaks everything.
The second figure, from Veracode, should not frighten you about generated code. It should make you ask your provider a precise question: who reviews, and by what method. A quote with no line for code review is selling you an agent's draft.
Where a project's weeks go, and which ones AI shortens
Here is how the work breaks down on a medium-sized business tool, of the intervention-management or job-tracking type for a company of thirty people.
| Stage | Historical weight | Effect of AI tools |
|---|---|---|
| Business interviews, scoping, trade-offs | 15 to 20% | Almost none |
| Design of screens and journeys | 10 to 15% | Strong on mock-ups, weak on choices |
| Build | 35 to 45% | Very strong |
| Migration and cleaning of existing data | 10 to 20% | Medium |
| Acceptance, fixes, special cases | 10 to 15% | Weak to medium |
| Training and support at start-up | 5 to 10% | None |
The heaviest item is also the one AI transforms the most. That is why timelines really do move. But since this item is not the whole project, the overall timeline does not collapse: it compresses.
An example, on a project we are delivering in mid-September: MyPosture, a training platform rebuilt entirely. Three distinct interfaces (learners, coaches, a complete administration), journeys and presentation materials editable from end to end, to the point that administrators now control almost all the texts and illustrations. An application already existed, built by others. We rebuilt everything from scratch, and that application served as our prototype: knowing precisely what the tool had to do removed weeks of uncertainty.
The result: two months of build. Redone cleanly from the start with 2023 methods, the same project would have taken us seven to eight months.
That time saved did not go into margin. It went into the two items that the table above gives as incompressible.
First, scoping. Our customers are not developers, and we do not ask them to be. They imagine something, and it is only on seeing the tool that they discover the missing idea, or teach us that a figure announced as fixed actually depends on three parameters. That information does not exist at the time of the quote. It comes out of use.
Then, the way we deliver. Since building costs less, we deliver during the build and not at the end. The customer receives mock-ups they really handle, and a comments module placed right on the screen, as on a shared mock-up, to tell us what is wrong where it is wrong. We no longer correct delivered software: we correct a prototype while it is still flexible.
"AI writes the code, so why pay €15,000?"
It is the question everybody asks now, and it is legitimate. Here is the answer in three parts.
You are not paying for lines of code. You are paying for the fact that someone spent six hours with your workshop manager understanding why an order can be "on hold" for four different reasons, and that those four reasons are found in the tool. That work is what makes software used or abandoned.
You are paying for a perimeter decision. From a list of thirty functions requested, a good builder removes twelve. Not out of laziness: because they complicate the tool for marginal use. That removal saves you more than any productivity gain on the code. What is never delegated to an agent is the choice of what to kill first.
You are paying for responsibility over time. Business software lives three to seven years. It evolves, it connects to other tools, it goes through a change in regulation. The total cost is not decided at delivery, it is decided over the duration. It is the same reasoning as for any software purchase, and we detailed it in our article on the price of custom software development.
The prototype and "vibe coding": useful, but not software
A practice has spread: describe what you want in everyday language, let a tool produce the application, adjust by eye. It is called vibe coding. For a business owner it is tempting, and for some uses it is the right choice.
When it is relevant:
- Testing an idea before committing a budget.
- A tool used by two or three people, with no sensitive data.
- Replacing a calculation file that has become unmanageable, with no continuity at stake.
- Showing your teams what the solution would look like before ordering it.
When it becomes risky:
- As soon as the tool holds customer data or payroll data.
- As soon as several people write to it at the same time.
- As soon as a day's outage costs money.
- As soon as you will have to evolve it without the person who produced it.
The problem is not the initial quality. The problem is invisible technical debt: a whole that works on day one, that nobody understands by day one hundred, and that has to be redone rather than modified. The cost of the rebuild largely cancels the initial saving.
The four questions to ask a provider who codes with AI
You do not need to be technical to sort two quotes. Ask these four questions.
1. Who reviews the code, and when? The right answer mentions systematic human review, not a final check. If nobody is named, walk away.
2. Who owns the code? Ownership of the code must be written in black and white, with the handing over of the sources. Without that, your tool is rented software that does not say so. You will not be able to change provider.
3. What happens in the third month? Ask what the follow-up covers, at what rhythm, and what is billed extra. A project delivered and abandoned costs more than a project followed up.
4. What are you not building? A provider who accepts everything you ask for is not advising you. They are executing. On a business tool, it is the best way to deliver an overengineered mess.
How we work, concretely
It would be dishonest to give you a reading grid without submitting to it ourselves. So here is how we do it, and what it really automates.
What is automated at our place is the production of code. The rest is not, and that is a choice of method, not a reservation of principle.
We move module by module, and each module goes through the same chain. We first write the specifications: what the module must do, and for whom. A human reviews them. We then derive the user journeys, what each person concretely does, screen by screen. A human reviews those too. The test plan is produced by the machine: it is mechanical, exhaustive work, exactly what it does better than we do. Then comes the build. Then a human check on screen, which answers a single question: does what is running match what the person who designed the module had in mind?
Two human reviews before the first line of code, one human check afterwards, and tests as we go rather than in a block at the end. The rule that holds the whole edifice together fits in one sentence: we never delegate an application end to end without stepping in. A project run like that only reveals its problem on the last day, and half the work then has to be undone. We would rather find it on the Tuesday of the second week.
The rest is workshop work. Scoping is done in person or by video call, never by form. There we see two populations that are often confused: those who order the software, and those who will use it every morning. They are rarely the same people, and the second group holds the rules nobody ever wrote down. Then regular check-ins, and one obsession: giving your administrators control over everything it is reasonable to make editable. A customer who has to call us to change a label is a customer we have served badly.
What it changes concretely for an SME of 10 to 80 employees
The good news is real: projects that could not be funded three years ago can be today. A production tracking tool specific to your workshop, a portal for your subcontractors, a quoting module that really follows your price list. This type of need did not justify €40,000. It can be handled today in a far more accessible range.
The bad news is just as real: the fall in production cost attracts offers that sell the easy part and forget the rest. The specification has never been so important, not as a hundred-page document, but as a clear agreement on what the tool does, what it does not do, and who uses it.
If you are still unsure about the very nature of the need, two complementary reads: what custom business software is and what management software is for.
What we write before writing a line of code
Since this whole article rests on the idea that the part that cannot be automated decides the result, we might as well show what it looks like.
The first deliverable of a project is called, at our place, a scoping document. Not a specification: that document is dense, specific and technical, and a business owner does not really read it. Ours is written to be read by someone for whom it is not their trade. It sets out the need, the goal of the tool, the features, what each one does, and who it is for.
The special cases and business rules are not in it yet. They come out at the next stage, prototyping, when you handle interactive mock-ups and give us your feedback as you use them. That is where you learn that an order can be "on hold" for four different reasons.
This document is billed, and it is yours. Billed because it is time spent, and because it is a draft specification serious enough for you to stop there, go and ask two other providers for quotes, and finally compare them on an identical basis. We prefer that to a free scoping that ties you in.
On our side, it is nothing like a formal document: it fixes the architecture and the split into modules, and the whole build follows from it. It is also the hardest passage in the trade, the one where a commercial reality is translated into something that can be built.
In summary
AI has changed one important thing: building costs less and goes faster. It has changed nothing about what makes an internal software succeed or fail, that is, understanding of the business, perimeter trade-offs, the quality of data migration and adoption by the teams.
A very low quote is not necessarily lying. It simply describes a shorter perimeter. Your job as a business owner is to check what is missing, not to compare two totals.
Sorting it out for your case
You do not need a specification to know whether a custom tool is justified in your company, or to read two quotes that differ tenfold correctly. Three questions are enough: which file is blocking you today, how many hours a week it costs, and what happens when the person who keeps it is absent.
The Magram diagnosis answers these three questions in about ten minutes. You leave with a costed order of magnitude and a frank opinion, including when the answer is "market software will be enough".
A question about your situation?
Ask Quentin, he replies personally.
