Skip to content

The Floor Is Rising

PMs aren't building your features yet, but AI tools are steadily eating the tasks that fill your week. The squeeze isn't coming from the side. It's rising from below. Each automated task raises the floor on what counts as "real engineering work."

What automation from below feels like

The side squeeze is dramatic. A PM walks in with a working prototype and the room shifts. Automation from below is quieter. It happens one ticket at a time.

The boilerplate you used to write gets generated. The test scaffolding runs itself. The CRUD endpoint that took an afternoon now takes ten minutes with an AI coding agent. None of these moments feel like a crisis. Each one just makes the task slightly less yours.

The cumulative effect is what matters. Nearly 70% of routine programming tasks have already been affected by automation. Not replaced entirely, but compressed. The time between "ticket created" and "code merged" shrinks, and the share of that time that requires your specific judgment shrinks with it.

The floor is rising. The work that used to sit comfortably above the automation line is now at the line, and the line keeps climbing.

Why this squeeze is harder to see than the side squeeze

When a PM ships a prototype, you notice. When AI shaves twenty minutes off your afternoon, you don't. You feel more productive. You might even feel safer, because you're using the tools well.

But productivity and safety are different measurements. You can be highly productive at work that's becoming worthless. The tasks get done faster, yes. But faster execution of commoditized work doesn't make the work less commoditized. It makes the worker more interchangeable.

The uncomfortable truth: the time you spend on automatable work is time you're not spending building the ceiling-level skills that AI can't touch. Every hour steering AI output on a structured ticket is an hour not spent learning what breaks under load, tracing a production incident to its design decision, or catching the failure mode that a solo builder can't see.

What's being commoditized and what isn't

The automation line follows a pattern. Work that can be specified as input-output relationships gets automated first. Given this ticket, produce this code. Given this test description, generate this test. Given this API spec, scaffold this endpoint.

What stays above the line is work that requires context the AI doesn't have:

  • Why this approach and not that one. The AI can implement either. It cannot judge which one survives the requirements you'll discover next quarter.
  • What happens in year two. The AI optimizes for the current task. It doesn't model the migration path, the team that inherits the code, or the feature that this data model quietly prevents.
  • What the system does under stress. The AI has never been paged. It doesn't know what a cascading failure looks like from the inside, or why the retry logic that looks correct on paper amplifies the outage it was meant to contain.
  • What's missing. The AI fills in what you ask for. It doesn't notice the question you forgot to ask. That adversarial instinct, seeing the gap in someone else's thinking, is a human skill that gets sharper with practice, not obsolete with automation.

How to climb above the rising floor

Map your last two weeks of work. Separate the tasks into two categories: work where your judgment was the bottleneck (the decision that required your specific context, experience, or adversarial instinct) and work where your hands were the bottleneck (the implementation that could have been specified and handed to an AI agent).

The ratio tells you how much of your role is above the floor. If it's less than half, the floor is already close.

To shift the ratio, stop competing with AI on the work it's good at. Instead, invest in the infrastructure layer: learn one database, queue, or cache your team relies on past the tutorial level. Read the source. Break it intentionally. Understand why it makes the tradeoffs it does.

Trace a real outage to the design decision that caused it. Follow the chain backward until you hit the architectural choice that made the failure inevitable. That chain is invisible to someone who has only built things that work on localhost.

Take the migration nobody wants. The legacy system, the data model that grew organically, the on-call rotation. These are where production intuition forms, and they're exactly the work no AI agent is competing for. The unglamorous work is where the moat gets built.

The question worth sitting with

Which of your daily tasks would you miss least if AI took them, and what would you do with the hours? If the answer is "more of the same," the floor is rising and you're standing still. If the answer points toward depth, architecture, or production ownership, you've found the direction. The floor will keep climbing. The only question is whether you climb faster.