The debate about AI and software engineering is focused on the wrong thing.
One side says AI will make engineers far more productive. The other says it will fill codebases with AI slop.
Both sides are right.
AI is not good or bad by itself. It is leverage. And leverage amplifies the system it is placed inside.
If a team has strong feedback loops, AI can help it learn faster. If a team has weak feedback loops, AI will probably make the mess bigger.
AI increases output. But output is not the same thing as progress.
Output without feedback becomes waste.
Output with fast feedback becomes learning.
That is the real distinction.
Evolution, markets, learning, and startups all run on the same basic pattern:
Variation.
Signal.
Correction.
Repeat.
Engineering works the same way.
We have an idea. We turn it into code. Production, customers, teammates, logs, tests, and reality tell us where the idea was wrong. Then we update the code, the tests, the architecture, or our own beliefs.
The team changes the system.
The system teaches the team.
The team changes again.
That loop matters more than most teams realize.
Google’s DORA research has pointed at this for years. DORA stands for DevOps Research and Assessment. Its research on software delivery performance argues that the best teams are not measured by how much code they write. They are measured by how well they balance speed and stability:
When production breaks, how fast do you know?
How fast do you understand?
How fast do you recover?
How fast does the lesson become a better test, trace, alert, runbook, or design?
A bad team learns late.
A good team learns fast.
This is why “bug count” is a weak metric. A team can have few software bugs because they write careful software. Or because they barely ship. Or because nobody is looking. Or because users have stopped complaining.
The better question is:
When reality disagrees with you, how quickly does your team update?
That is what Agile software development was supposed to mean before it became a calendar ritual.
Not standups.
Not tickets.
Not ceremonies.
A small step.
A real signal.
A correction.
Repeat.
Waterfall was not stupid. It fit a world where software shipped slowly, distribution was expensive, and feedback arrived late. Agile spread because the web made feedback cheaper, faster, and more continuous.
AI is making the same lesson obvious again.
Charity Majors makes this point well in “AI Demands More Engineering Discipline. Not Less.” AI does not remove the need for tests, observability, ownership, small deploys, and honest incident review. It raises the cost of not having them.
AI can help an engineer understand a codebase, write tests, scaffold features, summarize logs, and explore ideas.
It can also generate plausible garbage, copy bad patterns, hide complexity, and create code nobody owns.
So the question is not:
Should we use AI?
The better question is:
What happens to our loop when we use AI?
Does deployment frequency improve?
Does lead time for changes improve?
Does change failure rate improve?
Does failed deployment recovery time improve?
Does the team understand the system better, or merely produce more code?
This is old-school pragmatism in a new costume: make small changes, keep them reversible, test what matters, and stay close to reality.
Pick a workflow.
Measure the current state.
Add AI carefully.
Measure again.
Keep what helps.
Cut what hurts.
Repeat.
But be careful: not every feedback loop is healthy. A team can optimize for the wrong signal and get worse faster. Ticket velocity can produce low-value work. Faster pull requests can lead to weaker code review. More deployments can hide less understanding.
The signal matters.
AI slop is what happens when output outruns feedback.
Productivity is what happens when feedback gets faster too.
The best teams will not be the most pro-AI.
They will not be the most anti-AI.
They will be the teams that can update their beliefs the fastest without losing discipline.
They will know where they are.
They will make a move.
They will measure what happened.
They will update.
The loop is the leverage.
Don’t underestimate it.