It’s 2026, and it feels strange to admit, but I’m not really writing code by hand anymore.
Recently, I built an entire Rust-based image compressor. This tool compiles to WebAssembly and is wrapped in a SvelteKit web app, allowing users to drop in images for compression and resizing. The remarkable part? I built all of this without writing any code by hand, relying entirely on coding agents.
I even built a Space Invaders clone, a project in a domain where I had zero knowledge of the underlying hardware. I was able to work with coding agents to write Verilog code and program the hardware on the device itself, which is just incredible. Six months or a year ago, I would have never even attempted these projects. Now, they feel surprisingly easy to accomplish.
In this article, I want to discuss what this shift means for the future of software and reflect on my journey over the last half a year.
The Tectonic Shift in Software Engineering
About nine months ago, I published a piece about my search for the perfect text editor and IDE. I ultimately chose an editor because it had the best user experience, felt familiar, and was doing a fantastic job with its AI features. A few months later, I decided to join the company behind it. I’ve been there for about six months now, primarily because I could feel the landscape changing. Software engineering was transforming from underneath me, and I wanted to be part of figuring out what was next and help teach others how to navigate this journey.
I haven’t published much for the last six months, and a lot has happened in that time. Just a year ago, coding agents weren’t really a mainstream concept. Then, in 2025, we saw a surge in powerful coding assistants that gained immense popularity. This was coupled with the models themselves improving dramatically.
A year ago, before the latest generation of models, they hallucinated frequently and were quite poor at following instructions and calling tools. When you look at the newest models, they’ve gotten really good. It’s pretty remarkable how well they can generate code now. This has me reflecting on what this means for building software in general. If I’m being honest, the previous generation of models was probably better at coding than I wanted to admit. They have likely been “good enough” for a while, but you couldn’t use them reliably for most software engineering practices.
Now, heading into 2026, the current crop of models is definitely better at coding than me, and they’re allowing me to take on more ambitious tasks. But this has changed my perspective on what software engineering even is. Writing code was never really the bottleneck, especially for larger projects. So if writing code is now free or incredibly easy, what does that mean for the rest of the software development lifecycle?
Ambitious Projects Made Easy with AI
Before I get to some of my recommendations, I want to share a few things I’ve built in the past few months to help contextualize why I feel software is changing so much.
First, I moved a company website off a traditional CMS to a system based on Markdown and MDX files. I anticipated this would take weeks and might even require hiring contractors or an agency. Instead, I got it done in a matter of days for a very affordable cost, which was wild. That was my first experience where I thought, “Wow, I can be much more ambitious with what I ask coding agents for.”
The next project was the Rust-based image compressor I mentioned earlier. Again, I did this entirely with coding agents and wrote no code by hand. I thought for sure the models would struggle with Rust—a lower-level language compared to something like TypeScript—and with more complex computer science concepts like figuring out compression algorithms from scratch. If you look at the source code, it’s doing some pretty advanced stuff.
For example, a core part of the logic might involve a function to find the optimal compression level, which the AI could generate like this:
// A simplified, conceptual example of what an AI might generate
fn find_optimal_compression(image_data: &[u8], target_quality: f32) -> Vec<u8> {
let mut best_compression = Vec::new();
let mut min_diff = f32::MAX;
// Iterate through different compression levels to find the best fit
for level in (1..=10).rev() {
let compressed = compress_image(image_data, level);
let quality_diff = calculate_quality_difference(image_data, &compressed, target_quality);
if quality_diff < min_diff {
min_diff = quality_diff;
best_compression = compressed;
}
}
best_compression
}
Finally, there’s the game I’ve been working on for the Analogue Pocket, a modern Game Boy-like device. You can write code to program the hardware directly. This is something I have no experience with. I’m not a game developer; I’ve built some simple games in Python, but that’s many layers of abstraction higher. I was able to ask the model and agents questions and get significantly far, to the point where I could now build new games from scratch because I understand how it works.
My level of ambition has continued to rise, and I believe that trend will only accelerate through 2026.
Recommendations for Engineers in the AI Era
Here’s what I would recommend for you as you think about your job as a software engineer or even if you’re just writing code for fun.
1. Expect Models to Get Good at Everything
The natural reaction to this is to say, “Yeah, well, I work on this one niche thing where the model isn’t very good yet, so it will never get good.” I felt that way about Rust, lower-level code, and detailed computer science topics. Then, recently, the models just got really good at them.
I would expect that within the next year, the models will become proficient at most things you need to write code for in software engineering. This doesn’t mean our jobs are dead. I think it’s the opposite. There will be more demand than ever for software engineers and people who can effectively use these tools. It’s a bit of a paradox, but it has played out in history before.
By learning these tools—whatever coding agent you prefer—you will gain a significant advantage over those who are more hesitant or skeptical. Learning to use them well can put you significantly ahead. The entire profession is changing, and it’s worth earnestly giving these tools a chance.
2. Automate the Drudgery
You should use these tools to get rid of all the drudge work—the stuff you don’t want to do. A lot of software engineering is effectively copying and moving JSON files, figuring out why a shell script failed, or debugging a strange error message. There’s a lot of boilerplate and things you’d previously copy-paste from Stack Overflow.
Use coding agents for that stuff. Get rid of the boring parts and focus on what truly matters for the end product.
3. Become a Generalist and Build Things
Now that code is cheap, what really matters is your taste. Increasingly, an engineer’s role is blending into that of a generalist. It’s not just about the code. It’s about the product we’re building. How does it look? How does it function? What’s the UX? How are we going to market and sell this thing?
A great way to develop these skills is to go build things. Be a generalist and try the entire gamut of building something. Don’t just write the code and publish it. Get it out into the world, market it, get users, and build something people love. Figure out the right things to build. Those skills will be incredibly valuable for you as a software engineer over the next few years. The product engineers who embrace AI to do their job better will have a significant advantage. This trend was already happening back in 2024, but it’s been drastically expedited by AI.
4. Use AI to Learn, Not Just to Do
Take the time to really learn. If you rely on LLMs too much, they can trick you into thinking you understand a topic when you don’t. You don’t want to delegate your thinking to the agents. You want to use them to become smarter.
How do you do that? Ask the models lots of questions. It’s like having a brilliant pair programmer sitting beside you all the time, ready to answer unlimited questions without ever getting mad or thinking your question is dumb. Use that to your advantage.
One fun thing I’ve been doing on my latest projects is asking the model to generate a mini-course for me, creating guides that walk me through topics that are completely new. “Explain Verilog to me and how the syntax works.” “Explain the different layers of abstraction from the hardware to the code I’m writing and how it gets compiled.” These prompts can make on-demand learning much more accessible than reading ten textbooks. If you have the agency and the will to learn, you can gain a huge advantage right now.
Final Thoughts
My job now is to help engineers make this transition from the pre-AI world into a future where coding agents can write most of our software. It can feel weird, sometimes like an existential crisis, because it feels like you’re losing a part of what you love—building things.
But for me, I had to remember it was never just about the code. Writing code was rarely the bottleneck. It’s about building something great, something I’m proud of. And that is so much more than just the code. The question now is, how can I use AI to become even better at my craft, now that I have this incredible tool?
That’s what’s on my mind for 2026. It’s going to be a great year. I’m optimistic. Let me know what you think.