You Can Generate Faster Than You Can Read

The bottleneck moved.

For years
the slow part was typing.

Now four hundred lines
arrive in nine seconds,

and the slow part is you,
reading them.

We have not adjusted.

We still measure a good day
by how much appeared.

But nothing counts
until somebody understands it,

and understanding
did not get faster.

So the pile grows.

Code that runs.
Code that passes.
Code nobody has actually read.

It works
the way a stranger's directions work.

Fine until the first turn
you did not expect.

Then you are debugging
something you never wrote,
in a shape you did not choose,
at an hour you did not pick.

The honest limit is simple.

Do not accept
more than you can review.

Not more than you can skim.

More than you can review,

meaning you could defend
every decision in it
to someone who disagrees.

If that takes an hour,
then an hour is your budget,
whatever the machine can produce.

So ask for less.

One function, not one module.
One change, not one feature.

A first draft you can argue with,
rather than a finished thing
you are tempted to trust
because it is long
and it is tidy.

Tidy is not correct.

It never was.

The machine is simply better
at looking finished
than we ever were.

Read it the way you would
if a contractor handed you the keys
and left the country.

Because that is the arrangement.

It will not be there
when it fails.

You will.

There is a quiet cost, too.

Every line you accepted
without reading
is a line you cannot reason about
once the incident starts,

and the incident
does not care who typed it.

The old skill was producing.

The new skill is refusing.

Not this.
Not yet.
Not in that shape.

Generation is cheap now.

Attention is not,

and attention was always
the whole of the job.

Slow down at the only step
that ever mattered.

– Serguey Asael Shinder