No-Code, Agile, and the UI is Dead, Long Live AI
Tags: ai, lowcode, nocode
Published: 2024-06-06 12:42:42

Anyone having read my previous article about [AI functions](https://ainiro.io/blog/getting-started-with-ai-functions) will easily agree with me; No-code is dead. Sorry, dragging and dropping widgets into a form is simply an obsolete skill.

**Disclaimer**; I don't mean dead as in _"proper dead"_, I mean dead as in 100% of existing No-Code platforms have basically been rendered obsolete by AI, more specifically LLMs combined with AI functions. If you don't understand why, check out some of the following articles that were almost entirely created using nothing but prompt engineering and natural language.

* [Demonstrating our new AI functions](https://ainiro.io/blog/demonstrating-our-new-ai-functions)
* [How to build a Shopping Cart AI Chatbot](https://ainiro.io/blog/how-to-build-a-shopping-cart-ai-chatbot)
* [The Sickest B2B sales AI Chatbot you have Ever Seen](https://ainiro.io/blog/the-sickest-b2b-sales-ai-chatbot)

Check out the following example taken from our own AI chatbot demonstrating a simple _"Check the weather"_ AI function.

<img alt="Asking our AI chatbot about the weather" src="https://ainiro.io/assets/images/blog/asking-our-ai-chatbot-about-the-weather.png" style="max-width: 550px;margin-left: auto;margin-right: auto;">

## Prompt Engineering **is** Coding

Prompt Engineering is the art of instructing an LLM such as [ChatGPT](https://chat.openai.com) to do what you want it to do, using nothing but natural language, logic, and reason. The process is probably easily within reach of 80% of the world's population, while less than 0.3% of the world's population knows how to code.

This implies that prompt engineering becomes a better tool for _"democratizing software development"_ than No-Code, since it allows citizens to use what they already know to create highly rich and complex AI-based software.

> Citizens can use natural language combined with AI functions to create _"apps"_

To put that last sentence into perspective, realise that most of the _"code"_ required to create for instance the shopping cart illustrated in one of the above articles, was in fact prompt engineering and plain English.

Hence, by creating small reusable AI functions, such as we've got the ability to do at [AINIRO](https://ainiro.io/), any human being can prompt engineer a rich and complex AI app together, allowing his or her users to use natural language to interact with the software.

## Devs and Citizens, a Symbiotic Relationship

Contrary to the original No-Code _"revolution"_ (that never happened), the AI-based No-Code revolution gives room for traditional software developers. Citizens will need basic building blocks, such as for instance.

* Send email
* Save to CRM
* Import from E-Commerce
* Scrape website
* Search the web
* Send notification
* Check email
* Order plane ticket
* Etc ...

This implies that traditional software developers will have to work in a symbiotic relationship with citizen developers, resulting in a healthy collaboration between devs and citizens, providing incentives for both parties.

The citizen needs basic building blocks to compose together using prompt engineering, and the software developer needs somebody with better business knowledge to orchestrate these together solving some specific business requirement. To understand the value, realise the following truths.

1. The dev is great at creating software
2. The dev is terrible at understanding business
3. The citizen is great at understanding business
4. The citizen is terrible at creating software

If you believe in the above four truths, then AI and prompt engineering results in that the dev and the citizen can collaborate, doing what they both are good at - While the end result becomes much better software. The dev no longer have to guess what business wants, he doesn't even have to think about it. Caring about business requirements is the job of the citizen.

> The citizen thinks about business, the dev thinks about code, period!

## Nothing (really) changes

The paradox is that nothing really changes. The dev still creates software, while the citizen with business knowledge continues using English language to communicate his or her specification. The only difference is that instead of communicating the specification to the dev, the specification is communicated directly to the LLM, ending up with a basic ruleset, allowing the LLM to act upon and create working software as a consequence.

> Basically, the person with the most business knowledge can write a specification, and once done with the specification, the app is **done!**

## The Specification **is** the app

For almost 100 years software developers and project managers have had a wet dream. The dream was to be able to take a specification written in English, click a button, and turn it into working software. Today, with initiatives such as our AI functions, this is not only possible, but the specification **is** the app. Let me repeat that in case it got lost on you ...

> The specification **is** the app!

Yup, with our AI functions you can basically click deploy basic building blocks into your _"AI app"_, for then to orchestrate rich and complex apps together, using nothing but natural language. To understand the above, realise that the following is basically the implementation for our _"check the weather"_ function in our own chatbot.

<img alt="AI function training snippet for asking how the weather is" src="https://ainiro.io/assets/images/blog/weather-training-snippet-as-ai-function.png" style="max-width: 750px;margin-left: auto;margin-right: auto;">

Then realise that the above function was created using a single _"basic building block component"_. Prompt engineering something such as the above together should easily be within reach of 80% of the world's population.

## AI killed Agile

The paradox is that the above methodology also killed Agile. When all the business rules of the app are prompt engineered together, the dev doesn't even need to consider Agile processes, standups, Scrum or anything like that. The only thing the dev needs to consider, is to solve whatever _"basic building block problem"_ the citizen currently have. The process of creating software becomes as follows.

1. The citizen asks the dev for a basic building block component
2. The dev delivers it to the citizen
3. The citizen prompt engineers it together into his existing app
4. The citizen tests and quality assures his new feature
5. The feature is done!

## AI Killed the UI

The paradox is that I suspect the above process will over time be able to deliver functioning software _a lot_ faster than any traditional method. I also suspect it will be able to create much _better_ software. In fact, the only _"concern"_ possible to have at this point, is that it requires users of your app to stop having expectations to having a UI, and becoming used to interacting with _"the app"_ using natural language.

All your apps are basically reduced down to a simple textbox and a submit button, allowing you to reuse the same UI for all your apps.

> UI is dead, long live Natural Language!

With later additions, such as utilising the Whisper API from OpenAI, users can even talk to their apps, at which point having a screen will be considered _"optional"_. Whenever your users needs to interact with your app, they just turn on their microphone by clicking a button, and instruct the software what they want it to do using natural language and speech.

If you think the above resembles the promises of Siri, you're right. The problem with Siri of course was that it was a ridiculous implementation. With modern LLMs such as OpenAI and Anthropic, it becomes just like Siri, except it's actually working this time!

## An AI development platform

At this point, the only remaining missing part of the puzzle is having an AI-based software development platform. Well, we just so [happen to have one](https://docs.ainiro.io/). In fact, _"an AI-based software development platform based upon low-code and no-code"_ actually is our primary product. A Magic cloudlet literally **is** that platform.

With Magic you can basically _"drag and drop"_ AI functions into your LLM, facilitating for creating software such as illustrated above.

## Wrapping up

I must have pissed off the entire no-code software development community in the world with this article. They've spent years teaching themselves how to use Bubble and God knows what other _"No-Code platforms"_.

In addition, I've basically pissed on every single holy cow in existence within the software development community, such as Agile and UI. If I looked hard enough, I could probably piss on the rest too - But the point is __everything is changing__!

> You can accept it, and use it to your benefit - Or you can live in denial, and perish. The choice is yours. The future is going to happen anyway ...