They tell me software developers will soon be replaced by autonomous agents. Yet every single day, I encounter bad software. When AGI comes, can its first assignment be to ship a decent calendar app?
I'm not here to complain about bad software, at least not in this post. I'm here to make the case for quality software in an era where constraints on code production have been dramatically lifted.
You can vibe code at a buttery-smooth 120fps in Zed and generate code 24 hours a day if you're so inclined. But in a world of abundance, the bar should be higher for quality.
As software engineers, we should measure our contribution not in lines of code generated, but in reliable, well-designed systems that are easy to change and a pleasure to use.
There's a lot of talk online about the 10x (or even the 100x!) engineer. Most people are talking about how AI can help us make software faster and help us make more software. As craftspeople, we should look at AI and ask, "How can this help me build better software?"
If you've spent any time in a codebase that solves real problems, I'm sure you can relate to this sentiment: "I want this to be better, but I don't have time to fix it." The system is broken in ways that hobble our productivity and imagination, but we need to ship. There's always an incentive to achieve our goals by bending the existing system instead of revising it, even if that leaves the system "not quite right, but good enough."
Our values at Zed of "Shipping & Craftsmanship" exist as a pair for a reason. We should feel urgency, but we shouldn't be using urgency as an excuse to cut corners. Short-term gains aren't worth the cost of suboptimal velocity for the lifetime of the company. This is even more true now that a gnarly code base hinders not only our own ability to work in it, but also the ability of AI tools to be effective in it.
Recognizing this dynamic doesn't make it any easier to resolve. Since we're only learning about a system as we build it, we may not even know what the "right design" is until rather far into the system's development. Each of our many decisions may make sense in the moment, but over time they accumulate, and before we know it we find ourselves working in what feels like a legacy codebase—despite trying at every turn to avoid that outcome.
All of this makes it more critical than ever to evaluate contributions not by how many lines of code you touched, but by your impact on how reliable, understandable, and changeable the resulting system will be.
So how do we build good software? There are probably multiple ways, but I'll tell you mine. It requires taking ownership of the user's experience.
As a user of a code editor, I want a fast experience. If complex 3D games can run at 120 frames per second, there's no reason my editor couldn't render 2D text and rectangles that fast. That was my initial goal for Zed, although at the time I didn't know how to achieve it. One thing I did know, based on my past experience creating a code editor named Atom (and its spinoff, Electron), is that I'd have to look beyond web technology. Otherwise, I'd never be able to achieve an experience better than a web browser.
So I started over. But starting over meant taking on a much wider scope, learning a systems programming language with a sadistically helpful compiler, and learning to write shaders. All of that added risk to the project, but without it, Zed couldn't have become what it is today. Luckily, that kind of learning and de novo software development just got vastly easier, thanks to the power of LLMs. Even with hallucinations, I would have given almost anything to have a language model chat me through Rust borrow checker errors when I was first learning.
Taking full ownership over the user's experience is not as risky as it used to be. If we have the ambition to pursue an amazing experience, but only some of the skills necessary to deliver it, AI can help us overcome the knowledge gaps standing in our way. It won't be a drop-in substitute for actual expertise, and we'll still make mistakes as we go, but it will let us experiment faster, learn faster, and iterate faster than we ever could in the old days.
Aim high! The barrier to entry to building truly great experiences has never been lower.
AI agents have not existed for very long. We've already learned a lot about how best to use them, but there remains much to learn. What's more, the tools themselves continue to improve, which creates ever-moving goalposts in our pursuit of understanding.
In this rapidly evolving environment, how can we determine which skills and techniques work best with which tools? The same way we always have: sharing knowledge with one another!
That's why today, we're introducing Agentic Engineering—combining human craftsmanship with AI tools to build better software.
Every other week we'll be bringing on experts to hash things out with us. The line up is super exciting. Join us in our discovery and let's figure this out together.
Sign up below for invites to the live events and recaps in your inbox.
As we continue to sharpen my favorite tool, I'm excited to find ways to push the envelope with AI to help the world write not just more software, but better software.