LLMs and the No-code Trend
We've seen the "anyone can build software now" idea play out before.
There's a lot of talk about LLMs' role in software development. I think the role is going to be significant, though not as significant as some people make it out to be. There are some major roadblocks to LLM use and those roadblocks are more than theoretical. We saw them happen with no-code tools only a few years ago.
No-code tools are incredibly useful. Airtable streamlines turning spreadsheets into CRUD apps. Power Automate, Zapier, and IFTTT allowed anyone to create simple integrations between different software services. Bubble went farther and tried to allow anyone to make full blown web applications. Bubble also happens to have the most parallels with LLMs.
The primary assumption with Bubble allowing anyone to build web applications is that the hardest part of software development is writing code. That's only conditionally true: if the software requires a significant amount of computer science. This includes operating systems, cryptography, processing network packets, search, and the creation of LLMs (not using LLMs or building wrappers around them, creating the models themselves). The foundation of all software requires computer science. However, the vast majority of this complexity has been abstracted away. I remember being taught sorting algorithms in college and then being told the next week that we'll never have to write sorting algorithms ourselves. That's because every modern programming language has sorting built in. The hard part of writing the code has been done.
The vast majority of software built today uses that abstracted foundation. The code itself is relatively simple. Yet, building that software is still hard. Bubble, despite being a solid business, has not enabled my grandparents to suddenly build useable software. Many people end up hiring Bubble developers/consultants who charge an hourly rate as high as any freelance software developer. The resulting cost is still very significant despite not having to write any code.
The part that makes software development still hard is that software is not intelligent. It makes no assumptions and has no intuition. One of my college professors provided an excellent analogy for this. Imagine a person standing in front of a cup of coffee. Ask them to pick up the cup. Then ask them what time is it.
If you're wondering what the issue is, then you've also probably wondered why building software is so hard and why developers are so expensive. Here are the problems with those two requests:
There was no specification for whether the cup should have been picked up with the left hand or right hand
There was no specification on whether the person was wearing a watch or needed to take out their smartphone
There was no instruction to put down the coffee cup
That last one is a doozy. If the person picked up the cup with their left hand and had a watch on their left forearm, they would have spilled the coffee all over themselves when they turned their arm to look at their watch.
A human would have instintively put down the cup first or moved it to their other hand. Humans have a model of how the world works and consequences of certain actions. They will adjust their actions without even thinking about it. Software does not work like that. Software does exactly what you tell it to do. No more. No less. If you don't give it enough details with instructions, then it will just perform those instructions blindly regardless of the consequences.
This example is simple because the idea of not spilling coffee all over yourself is a common one. Things get a lot more complex when you start getting into specialties. What comes naturally to a sales person, an accountant, an educator, a lawyer, etc may not come naturally to a software developer. Every profession has their specialized skill set and many of them end up taking the basics for granted. Those basics are essential when communicating requirements to developers, but are often neglected.
This aspect frustrates a lot of inexperienced people who want to have some software built. They provide a general idea of how something should work without realizing that their idea has not been fully thought out. They get frustrated that the developers can't just make something work.
Spreadsheets are actually a fantastic tool here. They are the OG no-code tool and correlate fairly well to database tables. Every interaction in software: every button click, text input, drag and drop, etc, can be reflected in a spreadsheet. If someone can't map an interaction to a change in a spreadsheet, odds are they haven't thought their idea through. If the interactions in a spreadsheet are incredibly messy, the code will end up incredibly messy.
Doing that exercise is a lot harder than it sounds. That's the part that tools like Bubble are missing and LLMs are in the same boat. Tell an LLM to "just make X work" will not get you a high quality software application. Working through every detail and explicitly handling every possible assumption is required to get an LLM to deliver what you want. That part is where the biggest challenges are in the majority of software built today.