The Future of Software Engineering is Specification and Validation

The future of software engineering and programming is specification and validation. The latest addition to the toolbox are large-language models, especially the latest GPT versions. Copilot was also a big improvement when it came out, although still closer to a very good and context-aware auto-complete, than an actual intern¹. As the LLM boom continues and as capabilities continue to emerge, LLMs, together with older tools such as constraint solvers, code synthesis tools² and specification languages like TLA+, are turning into a powerful toolbox. As this toolbox grows and becomes easier to use, it seems inevitable that the role of an engineer will change. The important skills will shift towards being able to define and specify well what you want and, crucially, to being good at validating any output from your tools. Engineers who excel in these areas will have a leg up on the engineers that don't.

Over the last months I have used ChatGPT to get familiar with CSS and to create the style sheet you are currently looking at with no previous knowledge. Just start with a simple prompt to create a style sheet that contains a header, a footer, with a specific font and some other details and voilà, you have a starting point that helps guide further research and to get an overview of new terminology³. I have also used it to generate custom matplotlib plots and complicated SQL queries, saving some time. It also helped me navigate some documentation when I knew what I was looking for, but couldn't find the right terms to search for. In other words, ChatGPT has quickly become a part of my toolbox.

My background is operations research, and I previously worked in logistics where I was solving routing and scheduling problems. In this work I constantly work with solvers like Google's or-tools, a collection of solvers, and GUROBI, a state-of-the-art, proprietary solver. Most of the work here is always about specifying models that are then solved by the solvers. One doesn't have to think about how to solve something algorithmically⁴; only how to specify it correctly and to make sure that the model actually is accurate in capturing the real-world problem at hand. My hope is that more of programming goes this direction. If you can leverage this toolbox by having efficient ways of validating what works, both technically, i.e., it runs, and from a business point of view, i.e., that problem worth solving is actually being solved you have a very potent combination.

To be fair, typing is rarely the bottleneck in any project, although from personal experience it can be definitely be an obstacle to test things that might take some days of straightforward work. I also don't think that designing APIs and deciding on boundaries between services and modules will be solved by these tools as this is often as much a social problem as a technical one. However, I think we might be crossing a threshold where these tools might make it possible to actually discuss the pros and cons of concrete MVPs; not only hypothetical ones. This is really powerful as there is no better way to shape a discussion than having something concrete to point to.

I heard about a professional translator who said his job changed completely when machine translation became good enough. This is already more than a decade ago. He said that instead of slowly making a first pass and translating, this first pass is now done completely automatically and more effort is spent on making sure that translation conveys the same tone and feelings, making sure humour and idioms are carried over properly. However, this guy obviously already had a decade or more of experience with old way which had allowed him build up this intuiton and knowledge. Will we see the same for software engineers? Where senior engineering people can get that first MVP automatically, and then leverage their experience when integrating it and validating it? Every innovation opens some doors and closes others. Before we had calculators, being good at computing by hand was an important skill for mathematicians and scientists. Over a fairly short span of time this skill went from being foundational to irrelevant. Strong computers didn't have a leg up any longer over slower computers with other skills, e.g., more capacity for geometrical thinking, and those other skills become more important. I think the same is happening in software: creating good specifications, defining problems well and being able to efficiently validate are skills that are becoming more important.