Writing code got faster. Why didn't the work?

Keyboard: ← → to move, F for full screen, O for overview.

Tan shrugging, “works on my machine”

AI · Delivery · Brownfield

Writing code got faster. Why didn't the work?

AI didn't remove the bottleneck, it moved it. In an existing system, the real cost is finding and proving the rules.

Muhammet Şafak

Section 01

Bottleneck

AI didn't remove the bottleneck, it moved it.

One station

It didn't vanish. It moved.

Make writing 3× faster, but leave review and verification where they are, and you haven't tripled throughput.

The author's observation · one team I watched

Output went up; throughput went down.

  • ~2× Code output Roughly double once they leaned on agents
  • 6 Weeks later They were shipping more slowly
  • 3× PR queue The pull-request queue tripled
  • 2 Incidents Traced back to changes nobody had read

Delivery pipeline

Throughput follows the slowest station

  1. Step 1: Write got faster
  2. Step 2: Review
  3. Step 3: Integrate
  4. Step 4: Verify
  5. Step 5: Release

Where did the bottleneck go?

It was always expensive; now it's drowning

  • Review Generation produces PRs faster than humans can give them real attention; review degrades into rubber-stamping.
  • Verification Writing tests is nearly free; suites fill up with flaky, timing-dependent cases.
  • Integration More code means more coupling and more ways for the same message to arrive twice and corrupt state.

DORA 2024 and 2025 reports, as cited in the post

AI is an amplifier, not a shortcut.

Teams with strong delivery practices get more out of it; teams without them ship their dysfunction faster.

When does this not apply?

Know which world you're in

Greenfield, prototype, spike The constraint is still production
  • No downside to protect yet
  • Go fast
  • No process for a system not yet built
Team, review queue, production This is where the shift bites
  • There's something to keep honest
  • Other people depend on production
  • The bottleneck moves past the writing

Section 02

Brownfield

So what about a system that's been running for years?

Where the knowledge lives

Greenfield vs. brownfield

Greenfield vs. brownfield
Criterion Greenfield Brownfield
What is "correct"? You define it The system already defined it
Where is the knowledge? With you and whoever made the request In the code, the data, people's heads
Cost of a mistake Reversible Live data and users pay
Dominant cost Production Verification

What moves

What moves isn't code, it's rules.

In brownfield, what moves isn't code, it's rules. An agent is a multiplier where the knowledge is with you, and an assistant where the knowledge is in the system.

Where rules hide

Three places, three ways to dig

Code says what a rule is; usually only people know why.

  1. Unwritten exceptions in the code 3 business rules in 15 lines
  2. Implicit rules in the data status counts, what NULL means
  3. The reasoning in people's heads was it meant to be this way?

An honest breakdown of one week

Writing code is one day out of five

days, approximate

  • Rule discovery 1.5
  • Actual coding 1
  • Parity verification 1.5
  • Edge cases 0.5
  • Cutover and monitoring 0.5
Approximate breakdown, a single example: migrating a CRM module.

Where an agent is a multiplier, and where it's an assistant

What it speeds up and what it doesn't

  • Mechanical conversion Turning one pattern into another; minutes, not hours.
  • Reading code Extracting rules; the output is a list of questions, not an answer.
  • Verification tooling Scripts that compare old and new, characterization tests.
  • Validity of a rule An agent finds the rule; it can't tell you whether it's still wanted.
  • Verifying Showing it produces the same results as the old one is the daily work.
  • Cutover and coordination Not technically hard; but it takes up calendar.
Tan taking notes in a notebook

How I estimate brownfield work

Four rules

  • Count unknown rules, not lines. (pending)
  • Spend the first half day on discovery, then give the estimate. (pending)
  • Budget at least as much for verification as for production; the ratio comes out around 1:1.5. (pending)
  • Write the cutover as its own line item. (pending)

Writing code got faster. Understanding what the years mean did not.

Muhammet Şafak Fast from scratch, slow in a live system
Tan waving

Thank you

muhammetsafak.com

Sources: Engineering and Blog posts on muhammetsafak.com

Share, embed, download