Building in the Era of Autonomous Software Development

When you ride a Waymo in San Francisco, you see an empty driver’s seat and a steering wheel turning largely as a form of entertainment for the passengers. Sitting in the back seat, you can’t help but reflect on how dramatically cars will change over the next few decades as autonomous driving becomes pervasive. When cars move from autopilot to autonomous, you can not only rearrange the seats and remove the steering wheel, but perhaps transform our relationship with cars as the cost of ridesharing and robotaxis goes down so dramatically.

With the advent of large language models, we’re clearly already in the Autopilot Era of software engineering. Coding assistants like Cursor are helping individual computer programmers become much more productive, but largely within the scaffolding of programming environments that are optimized for humans: text editors optimized for humans like Visual Studio Code and programming languages optimized for humans like Python, all packaged as code completion so that the the computer programmer has to keep their hand on the steering wheel the entire time.

Despite the pace of innovation in coding assistants, it feels like we’re still missing some of the cornerstone ideas that could make truly autonomous software development a reality. What will software engineering look in the Autonomous Era, like when we get rid of the proverbial driver’s seat and steering wheel?

Each major milestone in computing has produced meaningful new computer programming systems. With Unix, we got C, which came to define the next four decades of programming languages. With the introduction of the Graphical User Interface (GUI) at Xerox PARC, we got the Integrated Development Environment (IDE) and programming languages like Smalltalk. With the proliferation of distributed systems and multiprocessors, we got abstractions like message passing that inspired popular modern programming languages like Go.

In the Autonomous Era of software engineering, the role of a software engineer will likely transform from being the author of computer code to being the operator of a code generating machine. What is a computer programming system built natively for that workflow?

If generating code is no longer a limiting factor, what types of programming languages should we build?

If a computer is generating most code, how do we make it easy for a software engineer to verify it does what they intend? What is the role of programming language design (e.g., what Rust did for memory safety)? What is the role of formal verification? What is the role of tests, CI/CD, and development workflows?

Today, a software engineer’s primary desktop is their editor. What is the Mission Control for a software engineer in the era of autonomous development?

Not only will answering these questions be fun and impactful, but I would argue we need to answer them soon. In this Autopilot Era, we are dramatically increasing the amount of software in the world, but that new software seems to contain the same security vulnerabilities and flaws as the code we were writing before, but with less oversight and maintainability.

With AI, we have an opportunity not just to create more software, but make software meaningfully more robust. Can we make a new software engineering system that enables us to not only be more productive, but produce fewer bugs and security vulnerabilities? Why shouldn’t every program be verifiably correct and run incredibly efficiently if AI is doing all the work? How much of the world’s unsafe software can be rewritten when we have such a system?

As an industry, I think we should be more ambitious and actively design the Autonomous Era of software engineering. If you’re working on these types of problems, I’d love to learn more and be inspired by your project.