My thoughts about AI tools and our ability to move faster have evolved.
When genAI coding tools first came out, my initial reaction was somewhat muted. I believe that coding is not really the bottleneck in software engineering. A software engineer only spends a fraction of their time writing code, the rest being spent on team meetings, design meetings, code reviews, debugging, and other activities. So a tool to speed up coding could only have a limited effect. If you spend 40% of your time coding. And you can make that time twice as productive, you’re not twice as productive as a whole.
In the beginning of 2026, the advent of Claude code and agentic coding changed my view. With the ability to instruct agents based on a spec, the ability to have multiple agents work in parallel, I felt like we would be able to do much more with less. And to a certain extent we have. I have talked about this earlier. We have seen a 40% increase in PRs and a similar increase in story points. That’s great.
But I feel like we are hitting some limits.
We still have to review the code, and there is much more code to review.
We don’t have good end-to-end testing infrastructure, ideally we would have more environments, and we’re lacking infrastructure on which we can orchestrate agents that can run tests that span multiple systems.
Most of the changes we want to make can only be deployed gradually so as to avoid catastrophic impact from bugs or mistakes, so we play with feature flags. Some changes require AB testing and there are only so many tests we can run in tandem.
AI tools are good at producing 90% of the solution, but it’s that 10% that’s really hard to nail.
And so, we can try to leverage the tools to automate more of the tasks we typically do: proof of concept, system design, code review, analysis, system design, debugging, simple bug fixing, triaging alerts, … That’s good and we should do all of that. But fundamentally, we follow a pattern: a product manager or an engineer brings ideas to the team, they get prioritized, designed, coded, reviewed, tested and deployed. And that’s the typical workflow. Some of these steps are accelerated through the use of AI, but the workflow has not changed.
Are we missing out? Our instinct is to take our existing workflows and try to automate them as much as possible. But we should think outside of the box. In what other ways can we leverage the tools to have highly impactful outcomes. One obvious thing that comes to mind is tech debt. Every engineer I know complains about tech debt. Agentic tools allow you to do massive refactors that we would have never undertaken before because it would take too much time and it would be hard to prioritize or it would be too risky. Documentation is another example. We should have AI write our documentation automatically, consistently. And the documentation should be written both for humans and for agents. But we can think bigger.
Could we build agents to migrate services?
Could we build a production level agent that scans our logs and metrics to proactively find bugs and proposes fixes?
Can we have agents predict when a system is about to fail and self-heal?
What else?
We should reframe our thinking from “How much time can we shave off our way of working?” to “How can we significantly improve quality? How can we deliver better software? How can we meaningfully reduce risk? Is there hidden business value that can be unlocked?” In short, how can we actively shift from simply faster to faster and better?