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

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

- Kind: Presentation
- Published: 2026-10-03
- Slides: 17
- Based on these articles: https://muhammetsafak.com/engineering/essays/ai-didnt-remove-the-bottleneck/ · https://muhammetsafak.com/blog/fast-from-scratch-slow-in-a-live-system/
- Source: https://muhammetsafak.com/visuals/d/ai-bottleneck-and-the-cost-of-brownfield/
- Language: en-US
- Author: Muhammet Şafak

---
## Slide 1 — Writing code got faster. Why didn't the work?

AI · Delivery · Brownfield

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

Muhammet Şafak October 3, 2026

## Slide 2 — Bottleneck

Section 01

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

## Slide 3

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.

## Slide 4 — Output went up; throughput went down.

The author's observation · one team I watched

-   ~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

## Slide 5 — Throughput follows the slowest station

Delivery pipeline

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

## Slide 6 — It was always expensive; now it's drowning

Where did the bottleneck go?

-   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.

## Slide 7

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.

## Slide 8 — Know which world you're in

When does this not apply?

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

## Slide 9 — Brownfield

Section 02

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

## Slide 10 — Greenfield vs. brownfield

Where the knowledge lives

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 |

## Slide 11

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.

## Slide 12 — Three places, three ways to dig

Where rules hide

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?

## Slide 13 — Writing code is one day out of five

An honest breakdown of one week

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.

## Slide 14 — What it speeds up and what it doesn't

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

-   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.

## Slide 15 — Four rules

How I estimate brownfield work

-   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)

## Slide 16

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

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

## Slide 17 — Thank you

[muhammetsafak.com](https://muhammetsafak.com)

Sources: Engineering and Blog posts on muhammetsafak.com
