Appendix AHow long would the configuration tool have taken by hand?

An estimate of what the configuration tool would have cost, and how long it would have taken, to build without generative AI, with its method and its assumptions, set against what it actually took. Optional reading: an order of magnitude for readers who want one, with the method stated so that they can check it.

At a glance

  • 300+

    Person-days by hand, on the lowest estimate, against 13 recorded with AI, counted as 26: manual work takes 12 to 15 times the effort.

  • €95,000+

    By hand, against €12,000 to €22,000 with AI, depending on the region: manual work costs 6 to 10 times as much.

  • 9 months

    Or more by hand, against 2½ months part-time with AI.

Figure 13. The configuration tool, built with AI and by hand.

What it covers

The configuration tool alone: 113 of the product's 172 stories, in the first leg of the project, built by one experienced person. The clinical application, access control and the other 59 stories are not estimated, nor are the documentation kept for the product as a whole and the people the product will need beyond the first gate.

How it leans

Every comparison uses the lowest manual figure, and doubles the time recorded on the AI side. Of the thirteen assumptions listed further down, six favour manual work, five favour the AI and two favour neither. The largest in the AI's favour, the reliability setting, is shown both ways.

Configuration tool: effort with AI and by hand, in person-daysWith AI: about 13 person-days recorded, counted as 26. By hand, from the stories, pending independent estimates: 473 to 773 working days. By hand, published model: 300 person-days at nominal reliability to 1,180.04008001,200person-daysWith AIrecorded, doubledWith AI recorded, doubled: 13, counted as 26 person-daysWith AI recorded, doubled: 13, counted as 26 person-days13, counted as 26By handstories, pendingBy hand stories, pending: 473 to 773 person-daysBy hand stories, pending: 473 to 773 person-days473 to 773By handpublished modelBy hand published model: 300 to 1,180 person-daysBy hand published model: 300 to 1,180 person-days300 to 1,180Solid: the lowest figureFaded: the range up to the highest
Figure 14. The configuration tool's effort, with AI and by hand, in person-days. Solid bars show the lowest figure, faded bars the range up to the highest; for the AI, the faded part is the allowance for work the records do not capture.

Why an estimate?

Chapter 01 makes no claim of a measured saving, because there is no measured baseline. What can be done instead is an estimate whose method is stated, so that anyone can check it, rerun it, or change the assumptions they disagree with. This appendix does that for one part of the product, with two methods that check each other, and it sets the assumptions on the side of manual work wherever there was a choice.

What is compared?

The configuration tool: the largest part of the product, and the least visible one (chapter 01). It is a good test because its work is well specified, and its code sits in a module of its own, so its size can be measured without guessing which story wrote which line.

Configuration tool, October 2026
Completed stories 113, in 18 epics
Acceptance criteria about 290
Tasks and subtasks 548 and 1,393
Review findings recorded in the stories 648
Automated tests 1,113
Product code, excluding comments and blank lines 8,112 lines of Java, 3,212 of HTML templates, 146 of JavaScript, 190 of SQL
Test code, excluding comments and blank lines 13,542 lines of Java
The eighteen epics

Screen authoring; field and widget catalogue; approval and release governance; palette window and field hierarchy; screen gallery and session lifecycle; application shell and navigation; resizable canvas; palette as an in-page panel; production-grade widgets; lexicon management; field catalogue extensions; publishing and baselines; session security hardening; list screens; selection-bound fields; relationship model and leaf-field placement; user management; action catalogue and placement.

What did it actually take?

The project's own records measure it. Claude Code keeps a timestamp for every prompt, and git one for every commit; together they show when I was working, and on which component. They put my working time on the whole product at about 24 days of eight hours between 31 July and 30 October, and the configuration tool's share at about 13 of them, between 8 and 15 depending on how the records are read. That is a measure of time at work with Claude Code, and the most reliable figure the project has: my own earlier estimate, about 20 days, was higher.

How the time was measured
  • Presence: 1,180 prompts on 55 days, each with its timestamp. Prompts less than 30 minutes apart form one working block, and each block ends 15 minutes after its last prompt: about 159 hours.
  • Calibration: the full session logs that survive, from 25 September, also show the time Claude worked between prompts. Over the same weeks they give 1.22 times the figure from prompts alone, and that factor is applied to the whole period: about 194 hours.
  • Split by component: blocks with commits by the files the commits changed; blocks without commits by the words in the prompts; shared work (quality system, requirements, build) spread in proportion. The configuration tool comes to about half.
  • Readings: with shorter or longer breaks between blocks, 125 to 229 hours for the whole product, so 8 to 15 days for the configuration tool.
  • Not captured: work away from Claude Code; session logs before 25 September; and, before the first commit on 18 August, any split other than by the words in the prompts.

The records see only the time spent working with Claude Code. Thinking away from the keyboard, reading sources, testing in the browser and discussions are missing. To allow for them, the comparison below counts the configuration tool's time twice: 26 days instead of 13. That is more than half-time would leave room for, so the allowance errs on the side of manual work. The first weeks went mostly to the configuration tool, while what I wanted came into focus, so these days include finding the requirement as well as building it.

My time is the main cost. To compare like with like, it is priced below as a salaried team would be, depending on the region; at what I would bill for a lead role on such a project, €900 to €1,000 a day, the 26 days would come to €23,000 to €26,000. The AI subscription adds about €30, half of three months.

How big is it?

Code written by an AI tends to be verbose. Most of that shows in the comments: they and blank lines make up 44% of the configuration tool's Java, and they are excluded above. On top of that, I assume that code written by hand would be 20 to 25% shorter, and both figures are used. Test code is left out of the size, because the model below already counts the effort of testing in its result; adding the tests would count them twice.

That gives a size of between 8,745 and 9,330 lines of product code.

First method: a published model

COCOMO II is a cost model developed at the University of Southern California, which turns the size of a piece of software into an effort in person-months, adjusted for the product and the team. Its equations and settings are published, and an online calculator lets anyone rerun them. I used the 2000 calibration, without recalibrating it on my own past projects, so its range is wide.

A word of caution. COCOMO is meant for ballpark figures of cost and duration, made early, when little else is known. It is neither a planning tool nor a method: it does not say what to build first, it does not forecast a delivery date, and it knows nothing of a team's real throughput. To plan, I would use what Agile Planning describes, a forecast made from observed throughput and stated as a range. Here the model is used for what it is good at: an order of magnitude, from published equations, that anyone can reproduce.

The settings used
  • Both cases: required reliability very high, as for safety-critical software. One person-month is counted as 19 days. The duration uses the model's own schedule equation, with no schedule compression.
  • Optimistic for manual work: a capable and experienced team (analysts, programmers, application, platform, language and tools all rated high), documentation rated high, and scale factors favourable: precedentedness and flexibility high, team cohesion very high.
  • Pessimistic for manual work: an average team, documentation rated very high, product complexity high, scale factors nominal.

Result: 378 to 1,180 person-days. The low end is the optimistic team with the 25% reduction in size; the high end, the average team with the 20% reduction.

One setting deserves a closer look. Required reliability very high adds 26% to the effort, to pay for the verification and validation a finished Class C deliverable needs, independent review among them. The configuration tool is not yet such a deliverable: it has had no independent review, parts of its development file are still templates, and nothing has been signed off (chapter 01). At nominal reliability, the manual estimate is 300 to 937 person-days. Both are shown below, so that the conclusion can be read without that setting.

The model also gives a duration, from the effort it has just computed: the schedule a team staffed at its best size would need, without compressing it. Here that is about 9 months for an average team of 2 people at the optimistic end, and about 14 months for a team of 4 to 5 at the pessimistic end. Compressing that schedule is possible, at the price of more effort, which the model also accounts for.

Second method: from the stories

The stories were sorted by size, by the number of tasks and subtasks they contain, and I estimated from experience how long a good developer would need for a typical story of each size by hand, tests and review included.

Size Stories Typical story By hand, per story Total
Small 19 A way back from the screen gallery to the landing page 1 to 2 days 19 to 38
Medium 76 Keeping two views of a page in step, in percentages 3 to 5 days 228 to 380
Large 18 Drawing a baseline from approved screens and their content 6 to 9 days 108 to 162
113 355 to 580

These ranges are my judgement, from experience of planning such work, and readers can substitute their own. They are in ideal days: time spent on the story alone. A developer's working day also holds meetings, interruptions and waiting, and the usual allowance is 0.6 to 0.8 ideal days for each working day. At 0.75, the middle of that range, the 355 to 580 ideal days become 473 to 773 working days, which is what a team would be paid for.

Those days need a team. By hand, I would give the configuration tool a Scrum team of its own, with three developers, two programmers and a tester, supported part-time by an architect and a database specialist, close to the mix of salaries below. Three developers take about 8 to 14 months over 473 to 773 working days. The application would need a team of its own, and so would each further component: one team for each bounded context is how Domain-Driven Design divides the work (chapter 08), and the work inside a context can only be shared among so many people. A product owner and a Scrum Master would come on top; they are left out of the figures.

This method is the weaker of the two. The sizes are my own, made after the fact, knowing how each story turned out, and BMAD cuts stories finer than a team working by hand would; a small story at one to two days will look generous to many web developers. It is pending: two or three senior developers are to estimate a sample of ten stories without seeing my figures, and their spread will be published here. Until then, the comparison rests on the published model alone.

What does it come to?

The published model puts the configuration tool, built by hand, at 300 person-days or more and about nine months or more, depending on how much verification is counted. The project's records put what it took at about 13 days of one person, counted here as 26, over about two and a half months of calendar time, part-time.

Configuration tool Person-days Duration
By hand, published model 378 to 1,180 about 9 to 14 months, teams of 2 to 5
By hand, published model, nominal reliability 300 to 937 about 9 to 13 months
By hand, from the stories, pending independent estimates 473 to 773 working days about 8 to 14 months, 3 developers
With AI, recorded about 13 (8 to 15) about 2½ months, part-time
With AI, counted for the comparison about 26

Effort

The comparison uses the lowest manual figure, the model's optimistic end, against the recorded time doubled: manual work comes out at about fifteen times the effort, and about twelve times at nominal reliability. On the highest reading of the records, doubled, it is still about ten to twelve times. This ratio needs no rates. The configuration tool's stories ran from 7 August to 16 October.

Cost

Cost needs a rate, and here the figures are less firm. France has no official reference for salaries. Several organisations publish their own, and they differ, most of all with where the team works. I used Silkhom's 2026 barometer, a comprehensive survey based on market analysis and one source among several, and took its figures for senior staff, seven years and more, in its three zones. An employer pays roughly one and a half times the gross salary, a common rule of thumb, over about 210 working days a year. The team's mix is 10% architect, 40% back-end developer, 25% front-end developer, 20% tester and 5% database developer. My own time is priced the same way, as the most expensive role I held on the project: a senior architect. Readers can substitute their own figures.

Configuration tool, salaried staff Paris area Large cities Other regions
Team's cost a day, blended €400 to €490 €335 to €410 €315 to €380
By hand, published model €150,000 to €575,000 €125,000 to €480,000 €120,000 to €445,000
By hand, published model, nominal reliability €120,000 to €455,000 €100,000 to €380,000 €95,000 to €355,000
By hand, from the stories, pending €190,000 to €375,000 €160,000 to €315,000 €150,000 to €290,000
With AI, 26 days as a senior architect €20,100 to €21,900 €13,700 to €15,500 €11,900 to €13,700
Lowest manual cost against cost with AI about 8 times about 9 to 10 times about 10 times
The same, at nominal reliability about 6 to 7 times about 7 to 8 times about 8 times

The same product costs about 30% more to build in the Paris area than in the other regions, and the ratio is lowest there, because a senior architect is paid a large premium in Paris. Freelance staff cost more a day: at the median freelance rates I observed in 2026, about €623 blended, and with my time at what I would bill as a freelance lead, €900 to €1,000 a day, the ratio comes out at about nine to ten times.

Which way each assumption leans
Assumption Leans towards
Comments excluded, and code written by hand taken as 20 to 25% shorter manual work
The model's optimistic end: an experienced, cohesive team, favourable scale factors manual work
Product owner and Scrum Master left out manual work
My time priced as a senior architect, the most expensive role I held manual work
Recorded time doubled, for the work the records do not capture manual work
Finding the requirement counted in my time, and nowhere in the estimate manual work
Both sides priced in the same zone, from the same survey neither
0.75 ideal days for each working day neither: the middle of the usual range
Manual work priced as a finished Class C deliverable, which the AI side is not yet the AI: shown both ways
Story sizes from my own judgement, made after the fact the AI, probably: independent estimates pending
Testers in the team, who are paid less than QA engineers the AI, slightly
An experienced person, who knew the domain, steering the AI the AI
One component, in the first leg only the AI

What the estimate does not say

It is an estimate, made with a model and with my judgement, and neither has been calibrated against a team building the same thing by hand. Size measured in lines of code is a rough guide to effort, which is why a second method was used.

The model's calibration dates from 2000, and frameworks and tools have raised productivity since. The optimistic settings rate tools and platform high, but a reader may still find the model slow, and can test it against a single figure. Its optimistic end implies about 23 lines of finished product code per person-day, across the whole team, testers included, with tests and comments not counted. For the ratio to fall below ten times, a team would need more than about 34 such lines a day on safety-critical code; below five times, more than about 68. Readers can set their own team's figure against those.

The model assumes a stable requirement, and this one was found along the way. The documentation a regulated product needs is counted only through the model's documentation setting.

Nor does the estimate reach beyond the first leg. One person holding every role was possible for a first component, and it would not be for a product going further. Past the first gate, the product needs people whatever it is built with: a product owner, regulatory affairs, a person for each module, an independent review, clinical validation. That work grows with the product and its obligations, the volume of code has little to do with it, and the AI compresses it far less (chapter 10). Over the whole project, the ratio would be lower than for this first component.

And the recorded days were not spent by the AI alone. They are the time of an experienced person deciding what to build, settling review findings and checking stories live, 121 of the 172 by the records. The estimate measures what the AI took off that person's hands, the volume, and the rest of the article is about what stayed in them.