Twelve years ago, in one company, we were deploying to production many times a day. Nothing dramatic about it. CI/CD pipelines ran, tests passed, code shipped – business as usual.
At another company, years after DevOps idea had gone mainstream, the reality was different for me. Deployments happened once a month if things went well. Realistically, once every two months. Meanwhile, high-performing teams were shipping dozens of times a week. Same industry, but different realities. I’m seeing a similar split around the use of AI in software development.
There was no shortage of “DevOps“ tools back then. Everyone was using CI/CD pipelines. Businesses started renaming the SysAdmins to “DevOps Engineers”. Unfortunately, their output remained the same.
The gap wasn’t in the tooling. The gap was cultural. The team had the people, process, and tools. But they were comfortable with their workflow. Merges would pile up for weeks before picking a date and a half-day-long release ceremony.
That DevOps culture of releasing many times a week was terrifying for some. Trusting a test pipeline instead of two QAs per engineer felt risky. Suggesting a change to the workflow raised concerns. A reasonable one: “We need to verify everything before releasing to production.”
DevOps wasn’t about recklessness – it was about building systems that made frequent releases safe. It took courage, support, and a willingness to deal with ambiguity for a while.
Our team pushed through this new way of thinking and built confidence. Suddenly, customer issues were getting fixed in hours instead of weeks. Customers didn’t care about the edge cases we missed. They cared that fixes shipped in days, not weeks.
Engineers stopped being people who write code and hand it off to QA or Ops to sort out. They became people who own the full lifecycle of what they build. We became a high-performing team, deploying many times a day.
Twelve years ago, the debate was about integrating operations into development. Today, it’s about integrating AI into how we think, plan, and build. If you lived through the DevOps transition, this should feel familiar.
DevOps changed what it meant to be a Senior Engineer. That redefinition is happening again.
Teams That Adopted DevOps Early Deployed 200x More Often – AI Creates the Same Divide
In 2016, the State of DevOps Report dropped a number that sounded like a typo: high-performing teams were deploying code 200 times more often than their low-performing peers.
These same teams had lead times measured in hours while others measured in months – a 2,555x difference. They recovered from failures 24 times faster. These weren’t teams with unlimited headcount. They’d changed how the system around them worked. Automation multiplied their output in ways individual effort never could.
We’re watching the same shift take shape with AI. DevOps automated the right half of the pipeline – everything between committed code and running in production: testing, building, deploying. AI is now automating the left half: from idea to working code. It’s a simplification, but a useful one. Together, they shorten the time from idea to shipped feature.
Teams that understand this aren’t treating AI as smarter autocomplete. They’re treating it as another automation layer in their delivery pipeline. AI builds on a foundation DevOps already made fast.
My team has been using AI-assisted development for the past few months. We used AI to draft the PRD, then aligned together. We used the PRD as context to generate a high-level system design. From the design, we broke down implementation into tickets. Each ticket is small enough that a coding agent could handle it and an engineer could review the output.
Our throughput has increased, but interestingly the quality went up as well. Because we front-loaded the thinking, we caught the unclear requirements early instead of deep in a PR review. We’re saving time from writing every line and reinvesting it into alignment and clarity earlier in the process. Each step creating context for the next. Lead time that used to take weeks now takes days.
The early data elsewhere shows a split is growing. GitHub’s research found developers completed tasks 55% faster using Copilot. Stack Overflow’s developer surveys show AI tool adoption doubling year-over-year.
Recently, Anthropic built a desktop agent (Claude CoWork) with a four-person team in ten days – using Claude Code, the same tool they were shipping to customers. A project like that would have taken a larger team several months. They’ve compressed the feedback loop between building and shipping.
I know those numbers sound too good to be true – they sound cherry-picked from ideal conditions. But look at the release cadence from GitHub, OpenAI, or even OpenSource software over the past few months – the pattern is hard to dismiss. These teams aren’t exceptional. They’re experimenting early. And the gap between them and everyone else is widening the same way it did in 2016.
Our Job Isn’t to Type Faster – It’s to Decide and Verify
When AI produces in seconds what took us hours to craft, it’s natural to wonder: what’s my value now? The anxiety might not be about AI taking our jobs. It’s probably more personal. If the things we spent years getting good at can be automated, where does that leave us?
But our role has shifted before, and in ways that felt like a stretch.
Fifteen years ago, being a senior engineer meant writing code, debugging it, making sure it ran on your machine, and then handing it off. Testing, deployment, maintenance – that was someone else’s problem.
When DevOps practices took hold, those boundaries dissolved. We started owning the pipeline – the CI/CD config, the infrastructure definitions, the monitoring dashboards, the incident response. The definition of “Senior Engineer” expanded from “writes good code” to “understands and owns the entire lifecycle.” It was overreach at first. But the engineers who leaned into it didn’t become less valuable – they became indispensable.
AI-assisted development is the same pattern. The role shifts from someone who wrote every line to someone who orchestrates the workflow – defining constraints, reviewing generated output, making sure the pieces fit and the system actually works. We’re not abandoning code, but where we spend our time is changing. Less time in the weeds of syntax, more time shaping the architecture of the solution.
This demands deeper thinking, not less. We have to understand and articulate the system before the code gets generated – defining what “correct” means, where the real trade-offs are, what the business actually needs. Our value is knowing which trade-offs matter and that only comes from having made the wrong call before.
Start Treating AI as an Automation Tool, Not a Magic Generator
So the role is shifting from writer to orchestrator. The mental model is simple. Following it through is the harder part.
AI is an automation tool. Think about Infrastructure as Code. We stopped manually configuring servers and started declaring the desired state in code. The tool (Terraform/CDK) doesn’t know why we want three replicas behind a load balancer – it makes it happen.
Writing a spec for an AI agent works the same way – like typing a destination into GPS. You describe where you want to end up, not which roads to take. We define the spec, constraints, and acceptance criteria; AI generates a draft. We review the output against our intent before committing it. The accountability stays with us. The execution gets automated.
Flip from “I write, AI assists” to “AI drafts, I review”
Most of us still work the traditional way. We write code and reach for AI when we get stuck. The AI becomes a search engine with better answers.
As AI agents are getting more effective, we should flip this. Let AI write first drafts from our specification; we review and refine.
Unlike CI/CD, AI is probabilistic, not deterministic – it won’t produce the same output twice and it will sometimes be wrong. But we’ve always reviewed code before shipping it. Whether it’s a pull request from a colleague or output from an agent, human judgment is still required. However, this saves us from typing the same boilerplate code hundreds of times.
Though, this feels wrong because it looks like we’re doing less. We aren’t – the effort moves elsewhere. If I spend three days implementing three patterns to find the best approach, I’ve invested heavily before I even know which direction is right. But if I spin up three coding agents and explore all three options in a few hours, I now have completed implementations to compare side by side.
I can see what’s working and what isn’t. The win is an information advantage. Instead of building one approach and guessing at the other two, I can evaluate all three with actual code.
It means doing the hard thinking earlier. Instead of spending time on typing, we spend time on reviewing, debugging, and adding quality gates.
Automate planning, not just coding
The more clearly we define what we want, the better AI performs. That means investing in requirements, identifying gaps, and agreeing on direction – before a single line of code gets written.
This brings product, design, and engineering into sync early. That alignment prevents the most expensive waste – building the wrong product
Treating AI as an automation tool means we’re not limited to using it for writing code. It applies across the product development cycle, from discovery to delivery.
For decades, there has been a familiar pattern in Engineering. A new layer of automation arrives, the pipeline gets shorter, and the engineers who adapt early define the new ways of working.
DevOps automated the right half – from code to production. AI is automating the left half – from idea to code. Together, they’ve collapsed what used to take weeks into days. Now the value of a Senior Software Engineer is shifting toward system design, breaking down problems, and reviewing the output carefully. The engineers who come out ahead won’t be the ones who typed the fastest. They’ll be the ones who learned to own the whole pipeline: defining what to build, specifying it clearly enough for an agent to execute, and verifying what comes back.
Software Engineering wasn’t the same 15 years ago. It won’t be the same 15 years from now. That’s not a threat – it’s a pattern we’ve lived through.
For your next development task, hand it to an AI agent and review what comes back. When it frustrates you – iterate on your understanding and learn from it. That’s the feedback loop for building the skill.
https://levelup.gitconnected.com/shifting-automation-to-the-left-how-ai-and-devops-are-reshaping-the-idea-to-release-0b2b01d5a390a>