AI Won't Speed Up Your Processes (And That's OK)

The dirty secret of AI productivity claims

Saw a post on HN this week (Frederick Van Brabant's piece) arguing that AI won't make your processes go faster, and honestly... yeah. After two years of integrating Copilot, Cursor, and Claude into my daily flow across four different teams, I've landed in roughly the same place. AI makes tasks faster. Processes? Not so much.

The distinction matters more than it sounds.

Tasks vs. processes

A task is the thing you do at your keyboard. Writing a function. Generating boilerplate. Drafting a gnarly regex. AI is genuinely excellent at these — I'd estimate it shaves 30-40% off my pure typing time when I'm in the zone.

A process is everything around the task. The Jira ticket sitting in "Ready for Review" for three days. The deploy that requires four approvals. The standup where you find out the requirements changed. The QA cycle. The customer who needs to validate the change before you can close anything.

Look at where your week actually goes:

# Rough breakdown of a typical product dev week (40 hours)
Writing code             ~8h   (20%)
Reviewing PRs            ~6h   (15%)
Meetings / standups      ~8h   (20%)
Waiting (CI, reviews)    ~6h   (15%)
Debugging existing bugs  ~5h   (12.5%)
Planning / refinement    ~4h   (10%)
Context switching tax    ~3h   (7.5%)

If "writing code" is 20% of your week, even doubling its speed saves you about 10% total. Amdahl's Law from college shows up uninvited and ruins the pitch deck.

What I've actually measured

I migrated three projects to a heavier AI-assisted workflow this year and tracked cycle time (first commit to production). Two of them got slower in the first month. Why?

• More PRs were getting opened (because writing them was easy)
• Reviewers became the new bottleneck
• A handful of AI-generated pieces had subtle bugs that ate days

By month three things normalized. Cycle time came back to baseline — not better. The team felt more productive (which is a real benefit, don't dismiss it) but the calendar didn't show it.

The review tax nobody talks about

Here's what nobody warns you about: AI shifts work from writing to reviewing. And reviewing is harder than writing.

# Looks fine at a glance, right?
def apply_discount(price, code):
    discounts = fetch_discount_table()
    multiplier = discounts.get(code, 1)  # default = no discount
    return price * multiplier

# Two problems hiding here:
# 1. fetch_discount_table() is called on every invocation — no caching
# 2. If `code` is None (very common from a form), .get(None, 1) silently returns 1
#    instead of raising. Bug that ships happily to prod.

When you write a function, you build a mental model as you go. When you review one, you reconstruct that model from the outside. With AI-generated code, you can't skip the careful review — sometimes it calls a method that doesn't exist, uses an outdated API pattern, or quietly swallows an error.

I tell junior devs on my team: treat every AI suggestion like a Stack Overflow answer from 2017. Often useful, never trusted blindly.

Where AI does actually compress the process

I don't want to be a total cynic — there are spots where AI shortens the process itself, not just the typing:

• Stack trace → likely cause: pasting an error and getting a focused minimal repro is faster than the back-and-forth on Slack
• Cross-language fluency: touching a service in a language you don't write daily, the ramp-up is real
• First-draft docs and ADRs: editing is faster than blank-page writing
• Test scaffolding: generating the obvious cases so you can focus on the weird ones

What these have in common: they replace a waiting step, not a typing step.

How to actually measure your process

Stop trusting vibes. Track the numbers.

Questions worth answering for your team:

• What's your median cycle time (PR opened → merged → deployed)?
• What's the median age of an open PR right now?
• How many PRs are open per dev on your team?
• How often does a PR need a second round of review changes?

For process metrics there's GitHub Insights, LinearB, and Swarmia. For product-side metrics on what users actually do with the features you ship, privacy-focused options like Umami or Plausible give you full data ownership without the GA bloat. The point isn't the specific tool — it's that you need some number that should move if AI is genuinely helping your pipeline.

If your AI rollout is real, at least one of these numbers should move. If none of them move, you didn't speed up your process. You just made some tasks feel snappier.

What actually moves the needle

The teams I've seen genuinely ship faster aren't the ones with the fanciest AI setups. They're the ones who fixed the boring stuff:

# A boring CI config that saves more time than any AI tool I've used
name: ship-it
on:
  pull_request:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 8     # fail fast — no 45 min stuck builds
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'npm'      # the cache line that saves ~2 min per run
      - run: npm ci
      - run: npm test -- --shard=${{ matrix.shard }}/4
    strategy:
      matrix:
        shard: [1, 2, 3, 4] # parallelize across 4 runners

Beyond CI, the cultural moves matter more:

• Set review WIP limits (max 2 open PRs per reviewer)
• Kill approval theater (one human approval, not three)
• Automate deploys (no manual gates outside of regulated environments)
• Write ADRs so decisions don't get re-litigated every sprint
• Trunk-based development, feature flags for the scary stuff

AI helps these teams more, because the process around the AI-generated code can actually keep up. AI hurts a slow team because it dumps more code into an already-clogged review pipe.

The honest version

I love using these tools. I'd fight someone to keep Cursor in my workflow, and I haven't tested every model thoroughly but the recent ones are clearly a step up. But when someone tells me their AI rollout is going to make the team "2x more productive," I ask what number they're going to measure. If they can't name one, I know exactly what's going to happen in six months.

The AI is faster. The process isn't. Until you fix the process, the AI is just helping you generate code that sits in a review queue with all the other code.