TL;DR

I coded my art school's ERP in 91,000 lines, in 4 weeks, with Claude Code. My dashboard valued it between €230,000 and €430,000. A weekend earlier, I had just understood that a five-figure consulting package signed a few months before with a commercial ERP vendor was worth nothing to us anymore. Here's how I discovered that the "lines × day-rate with AI discount" method will not survive any serious audit in 2027, and what I pivoted toward.

Who is writing this

My name is Michel Faure. I run L'Atelier Palissy, a network of traditional ceramics workshops, six sites in Paris and the greater Paris area. I'm not a developer by training. I run a structure that has to keep enrollments, scheduling, billing, communication, Qualiopi compliance and finance working for several hundred students. For four weeks, I've been coding the business ERP that replaces our pile of tools. Alone, with Claude Code.

That's the context for everything that follows.

The number that doesn't hold

As of April 14th, 2026, my dashboard proudly displayed: 90,947 lines, 345 commits, valuation €230k–€430k. I looked at it every morning. It gamified the work, gave it direction, justified the time invested.

The calculation was simple, which is what made it seductive:

Senior Next.js/Supabase day-rate   : €500–€700/day
Standard productivity              : ~125 lines/day
Design/debug/integration factor    : × 2.5
AI assistance discount             : ÷ 3 to 5

Each line of code was therefore worth, according to this model, between €8 and €14. 91,000 lines × range × business weighting = around €300k at the center. Apparently defensible.

Except that as I watched the number climb, a doubt settled in. And that doubt had a history.

The weekend that changed everything

A few months before starting Rembrandt — that's the name I gave our ERP — we had done what most French SMBs do: we had signed with a well-known European commercial ERP vendor. Annual licenses, a five-figure consulting package, contractually renewed tacitly, billing of custom developments per line of code produced.

The rollout was supposed to solve our problems. I didn't wait for the end of the rollout to ask myself a simple question, one Saturday morning: what if I built a prototype of our business workflow myself, in a weekend, with Claude Code?

By Monday evening, the prototype covered 70% of our critical needs. Not 70% of the vendor's promise: 70% of our reality. Courses, seats, enrollments, attendance, golden flow lead → enrollment. Functional, deployed, usable.

That weekend flipped two things:

1. The paid consulting package no longer served any purpose. Of the 100 hours of services planned, zero had been consumed. The vendor refused the refund. Firm position.
2. Billing per line became absurd. Paying per LOC for custom code when I was producing 3,000 lines a day with Claude Code was monetizing a unit whose real cost had been divided by ten.

And yet, holding that choice was much harder than the technical decision. Because we had already paid. Because the vendor wasn't refunding. Because the whole logic of amortizing the initial investment was pushing to continue. The sunk-cost fallacy, lived in real time.

It's by coming out of that dilemma that I started looking at my own valuation dashboard with suspicion.

The three structural flaws of the LOC model

1. The model runs counter to real cost

Claude Code keeps improving. Cursor too. Specialized assistants too. The cost of writing a line has been divided by 10 in 18 months, and the trajectory isn't over.

The faster I produce, the higher the dashboard climbs — while marginal production cost falls. By 2028, I could display 200,000 lines at €500k for a real cost of a few tens of thousands of euros. No accountant will sign that. No buyer will pay that. The metric lies louder and louder over time.

2. The model flattens commodity and singular

10,000 lines of generic CRUD on contacts and forms are replaceable by a SaaS at €100/month. 10,000 lines of catch-up logic × 4 periods × 6 sites × Qualiopi rules are non-substitutable.

Same volume, real values × 100 different. A LOC counter doesn't see that difference. It counts bytes, not value.

3. The model makes non-code assets invisible

My ERP contains around 3,000 historicized contacts, 5,000 qualified leads, 800 enrollments, 3 years of financial history, and 16 architecture decisions (ADRs) that capture the business logic knowingly. Not a line of code, a significant share of the patrimonial value.

The day someone were to buy the tool, they would pay for the data and the decisional capital as much as for the code. My LOC model made them invisible.

The pivot: four dimensions

I formalized the overhaul in an ADR and kept four axes:

The consolidated valuation is the sum of the four, not a max, not an average. Each dimension produces a min/center/max range, and every displayed euro can be justified by a transparent method and a traceable source.

The line counter stays in the dashboard but is demoted to the rank of production-volume indicator — the equivalent of a book's page count for an author. It no longer enters the monetary valuation.

What it changes concretely

• The displayed value no longer diverges from real production cost
• A drop in the line price to €5/line in 2028 doesn't break the model, because the model no longer depends on it
• Dimension 1 naturally produces a list of competitors to watch: if a vertical SaaS covers 80% of the scope at €200/month, the strategic signal is immediate
• The dialogue with the accountant becomes direct: the 4 dimensions map onto classic accounting categories (equivalent investment, productivity, intangible asset, goodwill)
• The "100k, 150k lines" achievements disappear from the dashboard: they rewarded volume, not value

The moment I really flipped

The same day, later. I had set my twenty-line guardrail so the counter would stop lying to me about SQL dumps, and I thought I'd won the morning. Around five in the afternoon, I go back to look at the delta cleaned of noise: 4,281 lines actually produced on the day, without the dump. I'm about to congratulate myself, and I stop.

Those 4,281 lines, I know what they contain. Mostly Sentry instrumentation, two CI scripts hardening a workflow already written, an attendance refactor that adds no functionality. Debt being repaid, not value being created. On paper, all equal before the counter. In fact, repaid debt isn't an asset, it's a non-liability.

I understand right there, precisely, that cleaning the inputs would never have been enough. The metric I had wanted wasn't dirty, it was structurally incapable of seeing the difference between producing value, repaying debt, and importing text. Three distinct economic natures, one counter, one euro per line. No AI discount, no weighting factor, no statistical correction would rescue that flattening.

The decision to pivot took no more than writing that sentence on a sticky note and sticking it to the edge of the screen. The next morning, I opened ADR-0009.

What I haven't yet resolved

The full overhaul of the valuation module represents about ten hours spread over three waves. The "usage value" dimension requires instrumenting hour measurements — timing your colleagues is socially costly, quarterly self-reporting is the only sustainable path. The "strategic value" dimension remains opinion-driven and requires an explicit framing of assumptions to stay defensible.

Finally, the switch produces a discontinuity in the dashboard. Going from €300k to €450k overnight without having written one additional line of code demands a visual annotation and a methodology note; otherwise it reads as a suspicious gain.

Three things to remember

1. The line of code is no longer a unit of value in the era of agent coding. It becomes what it always should have been: a production-volume indicator, nothing more.
2. Value what your code replaces, saves, captures, and makes possible — not what it cost to write. Production cost keeps falling, created value doesn't follow the same slope.
3. The real question isn't what you've already spent, it's what you'll save if you stop now. That's the hardest lesson to hold. It can't be proved with a spreadsheet. It holds against yourself, against the weight of past investments, against the social pressure to "finish what you started".

What about you?

If you code with an AI assistant and wonder about the value of your work, I'm curious: how do you measure it, today? And if you've already done the pivot "amortize a commercial ERP vs. build a custom tool with AI", share. Comments are open.

This article is part of a series on building a 91,000-line ERP in four weeks with Claude Code for L'Atelier Palissy, an art school. The next article details the four-dimension method in practice, with formulas and the module's initial seeds.

Companion code: rembrandt-samples/valorisation/ — the four-dimension consolidate(dims) pattern and Slack guardrail on the LOC counter, MIT, copy-pastable.