2025 will go down as the year code became cheap and programming changed forever. With agentic development tools—Claude Code, Codex CLI, Gemini CLI—engineers can produce far more code than ever before: prototypes, analysis scripts, migrations, refactors, bug fixes, tests, docs, and glue. But that doesn’t automatically translate into shipped value. In 2026 we’ll see the split: organizations that can adapt their processes and tooling to validate and deploy this new flood of changes will compound their advantage, while everyone else bottlenecks in review, testing, and release. The reason is simple: once coding speed jumps, everything around it becomes the constraint. Your throughput gets capped by whatever is slowest—clarifying requirements, reviewing changes, validating correctness and performance, getting to production safely, and operating what you shipped. In 2026, the great engineering divergence will be determined by who raises that ceiling end-to-end. Based on the pace of the last year, it’s reasonable to expect a few more major capability jumps from each lab in 2026: better tool use, more reliable instruction following, and longer usable context. I used most of the different models and agentic tools as they shipped, and I felt the shift firsthand—less “I’m writing code” and more “I’m directing work.” At this point, I expect most new code in many orgs to be AI-generated, with humans increasingly setting intent and validating outcomes. The most effective software teams at the end of 2026 will be wildly more productive than even the most effective software teams from the beginning of 2025. In less than 24 calendar months we'll have gone from one paradigm for software development to a new one that yields vastly more software than before. A single developer with multiple agents running in parallel paired with a software delivery process optimized for agentic development will run circles around everyone else. Although the rise in team productivity inequality will be driven in some small part by variance in individual adoption and effectiveness with AI, it will mostly be driven by the organization's ability to take advantage of every developer suddenly getting the ability to produce 10x to 1,000x more code than at any point before. Individuals may slowly adopt the tools, but by the middle of next year the cacophony of voices exclaiming how they're able to do so much more than before will be impossible to ignore. Amdahl's Law rules everything around me Amdahl's Law states that "the overall performance improvement gained by optimizing a single part of a system is limited by the fraction of time that the improved part is actually used." For those of us working on performance improvements in software systems (like InfluxDB), we're intimately familiar with this concept and use it to prioritize what optimizations to work on. Looking at software delivery, you could break it down into a number of things that have to happen: requirements gathering and customer feedback, writing issues, designs and specs, writing code, peer code review, performance testing and UX validation, safe production deployment, and monitoring the result. Code is only one aspect of this pipeline. If coding is 20% of the end-to-end cycle, making it 10x faster only yields ~1.25x overall speedup. To get 10x end-to-end, you have to speed up review, validation, release, and ops—not just typing. Put more succinctly: almost no organization's existing software delivery process is capable of taking in 10x more code produced by their developers. The code they produce will be put into the pipeline and they'll wait around for the slower parts to get it through. It is now possible to produce more code than you'd ever have time to review closely. This is likely why you'll see estimates of developers saying they're 20-50% more productive. My guess is that if their software delivery pipeline could take it, they'd be 10x, 100x or more productive. But they can't, so for many developers in 2026, their lives will simply get easier. They'll get a little bit more done in far less time and spend more time on UX, customer discovery, and higher-leverage work. For those who have doubts about all this, I'd suggest paying attention to what happens with the YC batches from Fall 25, Winter 26, and Spring 26. Anecdotally, a number of founders report that nearly all the code for the companies in this latest batch was written by AI, despite these companies having programmers in their founding teams. And because these are brand new companies with small new teams, they don't have processes in place to gate what gets done, by who and how quickly. It means they can apply AI force to optimize every part of software delivery, not just the code itself. If it’s mostly slop, you’ll see high churn: flaky systems, slow iteration despite lots of PRs, and customer trust issues. If it’s real, you’ll see tighter loops: faster experiments, faster fixes, and surprisingly robust systems for the team size. How to think about software development in 2026 Organizations that update their processes to improve the non-code chokepoints will reap the largest rewards. Specific focus on how to improve: • review bandwidth / ownership • testing and validation • release/rollback confidence • security/compliance gates • product decision latency (what to build next) The software delivery process should be updated to be accessible by agents. Software pipelines with these properties will be easier for agents to work in: • deterministic tests + fast local runs • “one command” dev environment • crisp module boundaries • docs colocated with code, and how to change X directions • golden datasets + perf harnesses • agent accessible observability across CI, performance, deployment and production The tooling can be iterated on with agents and it will quickly become obvious where they get tripped up and what they need to get the context in their window to solve problems. It'll be a lot of work, but thankfully, I'm guessing that the AI agents of 2026 will be able to help with all of this.