No code got the problem right and the solution wrong

TLDR:

1. There's an irreducible amount of complexity inherent in the development of any reasonably useful piece of software
2. Apps = boilerplate + context
3. No-code hid too much complexity, vibe coding doesn't hide enough

The basic premise of no-code is to allow anyone to write software by abstracting away the boilerplate parts—setting up a db, hosting a server, wiring up email—and letting users define behaviour through a simple UI rather than code. (See here, I love this piece)

I was an early believer. In 2020, I took a leave of absence from college to join the early team at Bubble. I helped to build the most powerful no-code framework on the planet, used by millions of entrepreneurs.

Unfortunately, no-code hasn't really lived up to its promise. In this post I'll share some thoughts about why, and make some recommendations on how vibe-coding platforms should take inspiration from no-code.

Why did no-code not work?

• There's an irreducible amount of complexity inherent to any reasonably useful piece of software.
• Types of complexity:
  • Product surface area e.g. what happens when a user quits midway through onboarding after making a profile?
  • Real-world messiness e.g. we need to write a separate flow for the visa application for each country
  • Architectural decisions e.g. do we expect this data type to have a >100 read:write ratio?
  • Design decisions e.g. should this piece of UI disappear on page width <1080 to make room for the rest of the page?
• Good abstraction design reduces complexity. But abstraction design is basically coding.
• The best way to represent a complex piece of application logic is code, not a no-code app builder UI. It's easy to ctrl-f, repeat logic, and source-control.
• The amount of irreducible complexity in an app is equal to the amount of context specific to that app.
• Anything in an app that's not context-dependent is boilerplate, and can be implemented by a no-code framework.

• Inevitably, any app built by no-code requires some bit of logic that isn't supported out of the box by a no-code framework. Some examples:
  • How many weekdays are there in between these two dates
  • Read from the user's clipboard
  • Trigger for when the app goes offline
• Related: every no-code app inevitably requires an integration with a third-party vendor that isn't supported out-of-the box by no-code.
• AI can mostly fix this problem.

• Learning how to code is hard; learning how to no-code is easier but not that much easier. As we saw above, some complexity is inherent to software. Any software builder needs to learn concepts like relational databases, responsiveness, interfaces and APIs to have a reasonable shot at success. This takes a while.
• The value prop of learning a no-code framework is made less appealing by the perception that the knowledge won't transfer off-platform, unlike coding.

• AI solves many of the above problems. It be fed information about an application and make reasonable design decisions to handle the context-specific complexity. It can write custom code for logic not covered by no-code frameworks. And it delivers results instantly.

Learnings from no-code

Keep

1. Abstracting away the true boilerplate complexity of building software.
   1. Software is context + boilerplate. There's a lot of boilerplate inherent to software development still— e.g. package management, secrets management, hosting, security.
   2. Current SOTA "vibe coding" tools lag behind no-code frameworks on this dimension.
2. Visual WYSIWYG editing
   1. It's easier to create pixel perfect designs with a figma-like editor than by prompting a chat window.
   2. The highest-throughput communication medium for visuals is visuals, not descriptions of designs.

Leave behind

1. Hiding implementations
   1. It was a bad idea to hide implementations of things like "send email". This was done in the name of simplicity, but in fact inevitably causes hidden undefined behavior.
2. New frameworks and languages
   1. AI builds Node/React apps better because the training data is abundant; popularity begets more data, which begets better AI performance and greater usage.