· translated from French

From handcrafted code to the software factory

Software is following the path of every tool that became too useful: the invention, the craftsman, then the factory. Most devs are still in the workshop. Those who leave it will be the best placed to set up agentic workflows for every other job.

Today, anyone can clone a SaaS in three hours with an LLM. A landing page, a dashboard, Stripe plugged in, and it is live the same evening.

So knowing how to ship no longer sets you apart. What does is holding up afterwards: the hundredth ticket, the thousandth customer, a codebase that grew sixfold in a quarter.

Other industries went through this moment before software, and they all got out of it the same way.

The workshop: every dev has become an augmented craftsman

Progress often comes in three stages:

  1. Someone invents a tool.
  2. Craftsmen learn to make it by hand. Each in their own way, but with shared patterns and a shared idea of what good design is.
  3. The tool becomes too useful to stay expensive. To bring its cost down, it gets made in a factory, on an assembly line.

The watch followed exactly this path. For centuries, watchmakers made them piece by piece, each workshop with its own methods, all with the same mechanical principles. In the mid-19th century, American manufacturers like Waltham started producing them with machines and interchangeable parts. Watches became affordable, and the trade shifted: nobody filed each gear anymore, people designed, tuned and inspected the line.

Software had its invention, then its decades of craftsmanship. The word is even claimed: the “software craftsmanship” movement talks about developers as craftsmen. Everyone codes in their own style, but everyone shares the same landmarks: design patterns, tests, code review, continuous integration.

LLMs first gave craftsmen better tools. Every dev has their Claude Code or their Codex (or even their Cursor), their prompts, their skills, their own way of working. It is still craftsmanship, just much faster.

Except a workshop that runs ten times faster is still a workshop.

The wall: most devs stay in the workshop

I think the vast majority of devs are stuck at this second stage. They still do everything by hand, just with Claude Code: launch the agent, review, fix, merge, repeat. They go much faster, but they never move to the next stage.

And at that speed, the workshop cracks. Here is a real production repository, in lines of code:

Date Lines of code Of which tests
Mid-August 230,000 40,000
Mid-September 448,000 120,000
Mid-October 857,000 310,000
Mid-November 1,540,000 661,000

Six times bigger in three months, tests sixteen times, more than 6,900 commits for a handful of developers. Nobody wrote that by hand: it is devs armed with agentic AI, each in their own corner, shipping fast.

That speed has a price:

  • bandwidth: nobody reads everything anymore, and humans spend their days approving instead of deciding;
  • costs: in tokens, in CI, in infrastructure, in hours of debugging;
  • velocity itself: a codebase that grows faster than anyone can understand it ends up slowing everyone down, agents included.

This repository is not an exception. In teams adopting AI, Faros measures +98% merged PRs, but also +91% time spent in review. We produce twice as much code, and spend almost twice as long reading it.

Watchmakers hit the same wall. They did not get past it with faster craftsmen, but with an assembly line.

In software, some have already made the jump, in case you missed it:

  • Warp popularized the pattern: one agent per stage (triage, spec, implementation, review, verification, deployment, monitoring), triggered by an event. Their “crawl, walk, run” post has become a reference.
  • Stripe runs Minions, agents launched from Slack or a bug report that go all the way to the pull request.
  • StrongDM went the furthest, with a factory where humans write the specs and the test scenarios, and agents do the rest.

The idea is not even new: Hitachi set up a “software factory” in the late 1960s, with human developers. What changes is that today, the stations on the line can be staffed by agents.

Designing the line: it starts before the ticket

Just like for the watch, a factory gets designed, tuned and inspected. The diagram at the top of this article shows the whole line, from question to answer.

The classic software factory diagram starts from a ticket. Except a ticket is already the result of a triage: someone decided the request deserved code. Before that triage, there are all the questions that reach the team. After deployment, there is someone still waiting for an answer.

So the line has three zones:

  1. Answer: understand the request, fetch the facts, answer or prepare the decision.
  2. Build: the software factory in the usual sense, from ticket to deployment.
  3. Close the loop: fix the data hit by the bug, check that the error is gone, tell the person who asked.

To make this concrete, let’s follow a fictional request from end to end. An account manager writes in the team channel: “Where is the refund for Durand SA?”

Answer

The answer agent handles three different requests, each with a different skill, then reviews before posting

The same morning, the agent gets two other unrelated requests, each routed to a skill with its own rules and its own tools. For Durand SA, the “customer accounts” skill finds the refund blocked for nine days, and the same error in the logs on eleven other accounts. It answers the AM and opens a qualified ticket.

Two things made the difference in this zone:

  • two readers, two messages: the person asking wants to know what they can do and when they will get an answer, the person deciding wants the facts. Mixing both in a single message fails both.
  • the right to stay quiet: when the agent has nothing useful to add, it posts nothing. A bot that answers “looking into it” to every message gets switched off within a week.

Build

The software factory stations, what each one does, and what happens to the Durand SA ticket

This is the part everyone calls the software factory. The Durand SA ticket moves from station to station, and a production error raised by monitoring enters exactly the same way.

Close the loop

After deployment: fix the data, check the error is gone, notify the requester

This is the zone most diagrams forget, even though it is the only one the requester sees. Without it, the twelve accounts would stay blocked after the fix, and the AM would follow up a week later without knowing it was solved.

Tuning the line: three rules and a daily loop

A running line drifts: business rules change, docs go stale, requests end up in the wrong place.

Three rules apply to every station, and they mattered more than the choice of model:

  • one agent per station, with a narrow scope, rather than one agent that does everything;
  • a bot identity for each agent, never a human’s key, so the audit trail shows what the machine did;
  • open the valves gradually: one station at a time, and no agent blocks a merge or creates a ticket without a human until it has proven itself.

Then the line gets tuned every day. Every morning, a job rereads the previous day’s threads (the 👍 / 👎 reactions, the corrections made by a human) and proposes at most three fixes: an outdated rule, a routing mistake, a missing tool. Most of the time, the problem is not the model, but a request sent to the wrong person or a rule that changed without the docs following.

Inspecting the line: measure before switching on

Replay: the agent replays requests that were already handled, posting nothing, until it clears both thresholds

A factory without quality control mass-produces defects. With agents, quality control is replay.

Before plugging the answer agent into the compliance channel, I ran it on 150 requests that had already been handled, without posting anything. Then I compared its answers with what the team had actually decided. An answer is useful if it saves time for the person deciding, and harmful if it contains a false fact, a bad recommendation, or internal information leaking to the requester.

The first run was bad: switched on as is, the agent would have been turned off the next day, and rightly so.

The fixes that paid off were structural changes, not case-by-case exceptions: splitting the two messages, reviewing before posting, putting the domain rules directly in the context. One iteration even pushed the score down: I had added a draft reply to the customer, and it produced most of the harmful answers. I removed it.

We never reached 80%. I switched it on anyway at 75%, because harmful was at zero and the pre-review decides nothing: a human always makes the call.

Each replay costs a few dozen dollars, far less than an agent you have to unplug after a week.

Beyond code: agentic workflows

For a while, I thought my job was to build a software factory. Then I looked at where the requests entering the line actually end up:

A hundred requests split into eight outcomes, with who handles them today and who handles them with agents

About 80% are settled without a line of code. Yet they eat the time of the most expensive people on the team: those who know the database, and those who know the rules.

The whole “Answer” zone has nothing to do with software engineering. A customer asks a question in the support tool, and that triggers a conversation with a CS or an account manager, a search through the docs, sometimes a manual action: changing a tool’s configuration, unblocking an account. It could just as well be a lawyer opening a client’s file.

So what I was building was wider than a software factory: an agentic workflow. Agents triggered by events, each plugged into its own tools and rules, with humans at the decision points. The software factory is just one zone of it, the one that produces code.

And every job done on a computer has its own line: requests coming in, research, decisions, manual actions.

I think the devs who leave the workshop will be the best placed to set up these workflows, for every job:

  • They know what a line has to check. Years of sprint plannings, baby steps, tests, CI/CD pipelines, and codebases that have to scale in complexity as well as in performance. Someone who vibe codes an app in two hours will have a hard time explaining to you why a CI blows up, or how to bring down a CI that takes 40 minutes.
  • They will have done it first, for their own job. The field is brand new, and they are the ones who will have the most experience with it.
  • It is technical work. Integrations everywhere, permissions, sometimes infrastructure to configure. All of that is much less abstract for an engineer than for a non-engineer.

Maybe that is the reassuring news for all the devs in the middle of an existential crisis. Tomorrow, a senior AM and an engineer will be able to handle the volume of a team of five AMs today. And the same goes for support, compliance, and probably plenty of other jobs.

Cloning a SaaS in three hours is something everyone will soon be able to do. Designing, tuning and inspecting the line that keeps it running is where the dev’s job is shifting, just like the watchmaker’s before it. And I don’t think it will stop at software.