# A 114-year-old playbook for AI software engineering

Most tech orgs are desperately behind.

They cling to two pizza teams, one PM, one designer, story points, sprint planning, and scrum. But those practices all rest on the same assumption: that writing software is slow.

With AI, this isn't true. Code was scarce and expensive, but AI has made code generation cheap. And when a scarce and expensive resource in a system becomes abundant, everything around it breaks.

## History, rhyming

Pre-assembly line Ford was more workshop than factory. Mechanics built entire cars end-to-end, and the quality of the car was a direct function of how skilled the mechanic was.

Ford turned this on its head.

In 1912, he stopped asking his craftsmen to build quality cars. Instead, he asked them to build a system that couldn't help but produce quality cars.

Following this mandate, a host of new specializations emerged:

The work needed orchestration. Production engineers organized the operations, the layout, the flow of raw materials to assembled goods.

It needed repeatability. Tool and die makers built the jigs, fixtures, and molds that ensured every car came out the same.

And it needed judgment. Foremen oversaw sections of the line, holding context across the system and using their expertise to intervene when something went off the rails.

Ford's assembly line didn't reduce the skill in the system. The craftsmen of the workshop became the foremen of the factory. The assembly line abstracted their skill, and gave it leverage.

History may not repeat itself, but it does rhyme. And right now it's rhyming pretty hard.

## The moving bottleneck

When one constraint in a system relaxes, another appears.

As code generation becomes cheap and abundant, the constraint is shifting to the things surrounding the code. Instead of generation being the limiting factor, it's verification, specification, and integration.

The new core constraints to producing software are:

Defining inputs. Ambiguity that a human developer would resolve through judgment and iteration becomes surface area for defects. Product specs are blueprints, and there's no room for interpretation when building an engine.

Quality gating. Static analysis, test coverage, linters, pattern consistency, code complexity. Checks that enforce output quality, even when unskilled labor is behind the wheel.

Throughput and velocity. CI/CD, observability, automated rollbacks, merge queues. Anything that allows the models to move faster is now amplified by the number of agents you can harness.

The practices that used to be luxury goods for mature engineering teams are now the baseline requirements for AI-assisted development.

## Quality as an emergent property

The biggest change with the assembly line was where quality came from.

Before, quality came from the craftsman. After, quality came from the system.

On an assembly line the craftsman didn't become obsolete. The craftsman's role became obsolete. Their knowledge lived on, encoded in better systems.

Software isn't losing its need for skill — it's developing a need for different skill, operating at a higher level of abstraction.

When the constraints in a system change, the system needs to change too.