During the last few months I have been feeling what a hand-loom weaver would have felt like when they first saw a power-loom. First denial, then shock (and as an entrepreneur, panic), then confusion and then acceptance. I have written programs for almost 30 years of my life, and my denial had lasted several months until the evidence was too strong to ignore. Programming requires breaking down the problem into smaller pieces and then building them one by one and stitching them back. It is closer to writing a novel than making a machine. You need to have good judgement and skill to write elegant and efficient logic. As of today, this skill has changed forever.

As most people would have experienced, seeing large language models (LLMs) write code and it feels astonishing. You just need to “prompt” the model what it needs to do and the model can flesh it out using generally acceptable programming paradigms. The model is trained on the best written software and can easily find adjacent patterns to your intent and merge it with the existing code. Along with this it also has the ability to plan out larger code bases. It can also decompose problems and make plans to execute phase-wise, so that it can “stitch” various snippets into a larger code-base. This means that you can write code by just instructing the model what you want, and letting the model figure out how to do it.

This makes it much like a “compiler”, a tool that takes a program written in high level languages like Python, and converts it into machine instructions. The models now take this one step further, you don’t need to know the computer’s language, you can write instructions in plain English. This means now anyone can instruct the computer to make software, not just people who know the computer’s language (coders). And the models are excellent at doing this translation from plain English to code. Almost as good or in cases even better than my 30 years of experience (with caveats).

So what does this mean for the future of computer engineering? One thing is very clear, it does not make sense to write code any more, when the models are already better. But that does not mean that all problems magically disappear. By default, the model can only copy existing software and ideas but can’t make new software. This is a point worth pausing on. If you want a duplicate of a tool that is out there, then the model is useful, but then if you want it to be even slightly different, you will have to make your own modifications and also own the consequences of those modifications.

This is where is starts getting tricky. Imagine someone has composed a tune and you want to change a small part of it. It is likely that your change shifts the balance of the tune and you will end up changing other parts as well. Similarly, writing software in the new way is also tricky and can require deep understanding of the domain and also taste for designing a good tool. The bottleneck for good software is not good code, but good design.

Good design in software was always valuable, but quite rare. Very few companies (like Apple) have “nailed” design. Most software still looks too confusing and too distracting. In the clothing industry, once making clothes becomes easy, the power shifted to those who have taste for quality and design, either in the clothes themselves or the retail experience. Since clothes are a part of our personality, we want it to be unique, just like us. Good clothes still require hand crafting to bring perfection and uniqueness. Similarly the software you use also reflects your taste. If you appreciate a quality experience, you may go with an Apple or a top end Google phone, but if you want something that is cost-efficient and “just works”, you will go for a cheaper phone. I reckon this what is going to happen to software. The product design and experience will be much more valuable, given everyone can ship similar functionality.

Designers and architects will also be able to get a lot done directly without needing programmers. Tough luck if your job is just to program. If you are a programmer, you will need to build an additional skills in architecture and design to sustain and grow in companies. Companies whose business is supplying programmers, will have to pivot to a new model since software development is going to require a lot less engineers than before.

Thinking back on my own experience, a lot of my job was decomposing the problem, simplifying it, architecting the platform, correctly “naming” things and designing it rather than just writing code. Code was how my ideas took shape. While I cared a lot about the “grammar” of code, it was mostly down to using the right paradigm - object oriented in my case - and choosing the right semantics. There were a lot of things about programming that I did not care about either. Like writing integrations, debugging style sheets, writing regular expressions, writing detailed tests etc. I am happy to let the agents take that job. I can still focus on the thing that I care about, decomposition, simplification and defining the right semantics for the tool I am building. So even for programmers, the world has become a much more fun place.

In the past few months as agentic coding has taken hold, we are yet to see “mind blowing” software being churned out showing that it is still hard to build great software purely with agents. Coding using models can take you from 0 to 1 very fast. But what about 1 to 10, 10 to 100? Using good primitives (like Frappe Framework) will take you from 1 to 10 fast, but going from 10 to 100 will take taste, stamina and vision. This will still take sometime as companies shift their focus from building to design and QA. This is the opportunity and moat for companies that survive. So while the engineer (builder) in me is shocked, the entrepreneur in me is still excited. If we can make this shift to design, adoption and quality faster, we can out-run our competitors. With the open source advantage, it will be hard to ignore us.

Personally, it feels both exciting and disorienting that the game has changed after 20 years. It has forced me to question the fundamental truths about building software. The principles of good design, architecture and semantics are more important than ever. What has changed is the velocity and the craft itself. It has become more accessible to a lot more people. This gives us the opportunity to redesign the organisation. The best example is customer support. Since traditional support is now almost gone, the job of our support team can now be to actually fix problems that customers report rather than delegating them to an engineer. A few non engineers have shown exceptional skills in building new software, that we hope will complete our portfolio of products.

While building software is going to be easy, making great software is going to continue to be as hard, if not harder. Even if the speed has increased, this part still remains the same. Great software companies used to be, and will be, the ones that create great software.