It’s impossible to do a software year-in-review for 2025 without talking about AI, so I decided to write the entire review through that lens.
Where I Started
When the year began, I was primarily using Cursor for small, one-off tasks: build a Stimulus controller, debug a specific issue, or generate a class here or there. It took quite a while before I could trust it enough and get organized enough to build real features.
I had some solid wins, but also some big misses. I enjoyed having AI do many of the things that did not spark joy, but I was still highly skeptical. I was confident it would eventually get better, but I would be lying if I said I expected AI to be writing most of my code by the end of the year.
The Turning Point
In June, I watched Ryan Carson’s video, A 3-step AI coding workflow for solo founders. This was a pivotal moment.
It wasn’t so much Ryan’s three steps themselves, but rather the underlying idea: be deliberate with what you prompt, and be intentional about what goes into the context window. I tried it on my next big PR. I generated a comprehensive PRD and let Claude do its thing. A couple of hours later, I had more code than I realistically knew what to do with. But more importantly, I had a feature that met every one of my needs.
From there I learned to manage scope more efficiently, but most importantly, I felt like I had a clear path forward. As the year went on, managing and minimizing what needed to be in the context window became a much larger focus. The idea of restarting your context window any time Claude says “you’re absolutely right” seems silly, but it’s the truth. At that point, your context window is corrupted[1].
Dex Horthy deserves a shout-out here as well. He has been ringing the bell about managing your context window more than anyone else I’ve heard this year.
Anthropic Won the Year
Thinking back to what was possible in January versus what you get now is staggering. In January, we were on Claude 3.5. It was okay. We were still learning the tools, and it wasn’t nearly as capable. Fast forward to the end of the year with Opus 4.5, and the results are remarkable.
Anthropic won 2025 for me. They ended the year with my preferred model (Opus 4.5), started the TUI coding revolution with Claude Code, and introduced skills. All three are now an integral part of my everyday coding experience, and I’m guessing the same for many of you.
What’s really interesting is that I doubt Claude Code and Skills were items Anthropic knew would be so popular and important. My guess is they were built primarily to learn how developers use their models, and the popularity was a happy accident.
Surprises
Google’s resurgence. This shouldn’t be a surprise given their sheer scale and resources, but from where they started the year to where they ended it with Gemini, it’s been eye-opening. They’re clearly the elephant in the room, and it’s clear they’re not going away.
The speed of improvement. What I can generate in December versus what was possible in January is not incremental. It’s exponential. The combination of better models, better tools, and better workflows has created a compounding effect that I don’t think any of us fully anticipated.
Self Reviews. There may be over 100 companies trying to do some kind of post PR code review tool. But simply asking a (different) model or two to review your code provides quite impressive results. On one hand, you might expect the model to get it right from the start, but like a human, sometimes it is easier to see issues once the full picture is in front of you.
My Tool Journey
January - June: I primarily used Cursor. I remember seeing post after post about Claude Code (released in February), but I couldn’t wrap my head around the TUI experience. The idea of my coding tool being so directly tied to one model provider seemed wrong.
July - October: By mid-July, I was hooked and went all-in on Claude Code. There were experiments with other tools along the way: Kiro, Codex, etc. There were even a few months when I primarily used Claude Code in Cursor’s terminal.
October - November: Once I was no longer using Cursor’s features, I turned my sights on a better IDE experience and rediscovered Zed (Claude CLI in Zed’s better terminal).
Late November - present: I started using both Amp and OpenCode. What I like about both tools is they embrace multiple models, but in drastically different ways.
Amp uses specific models for specific tasks. It’s a very opinionated tool and a joy to use. Think of Amp as the Rails of code generation tools.
On the other end of the spectrum is the open source tool OpenCode. You have access to just about any model you want (assuming you have an API key). This took me a bit to wrap my head around, but once I had it set up, it’s been fantastic.
99% of the code I generate these days still comes from Opus 4.5[2], but it’s no longer tied to a tool managed by the model provider. That gives me solace.
How My Code Generation Evolved
Looking back over the year, the progress is amazing. In January, whether it was skill or just comfort level, I wasn’t willing to do much more than generate a class here or there, build a Stimulus controller, fix a bug, or help diagnose something. Just small things.
As the year went on, what I was able to create became increasingly more impressive. There were times when it generated too much without proper controls. But where things are today, you can methodically have it generate major features in an extremely clean way, with nicely written tests, proper linting, and code that increasingly looks like something you’d write yourself. It might not match your personal style 100%, but we’re getting there.
Code Is Temporary
For most of the year, I worked on a project with three to five other developers. One of the bigger challenges was having AI generate code that didn’t just resemble something I would write, but something that matched the style of the team.
This has gotten much better in the last couple of months. The combination of better models, skills/rules files, and being more deliberate about context has made a real difference, in addition to the entire team largely using AI the same way.
But the other realization is that code is increasingly temporary. You are not wasting weeks and months on a wrong turn. You are increasingly more free to experiment and try new things, because the code can simply be discarded and replaced with something better in short order.
This changes the economics of software development. When the cost of experimentation approaches zero, the optimal strategy shifts toward more experimentation, faster iteration, and less investment in being right the first time.
Not Going Back
I enjoy writing code. Solving complex problems is fun. Figuring out how all the pieces of a codebase fit together is also fun. But the world of software changed this year, and it is not going back.
I am sure there will be opportunities for all of us from time to time to handcraft some artisanal code, but in 2026 and beyond, I fully expect I will increasingly rely on AI to write most of my code. My responsibilities are shifting more towards shepherding a clean and understandable solution.
The question for 2026 isn’t whether AI will write code, it’s what kind of software becomes possible when writing code is no longer the bottleneck.
