Transform your Use Cases to Software with ZERO Code
Tags: lowcode, ai, productivity, programming
Published: 2024-06-16 15:29:38

Being able to transform a formal specification into working software has been the wet dream of every single project manager for half a century. Simply put, because 99% of all time and resources are spent in the implementation phase. If you can skip the implementation phase, you're basically saving 99% of your resources.

Over the last couple of weeks we've been working extensively on [AI Functions](https://ainiro.io/blog/getting-started-with-ai-functions). AI Functions are small building blocks performing some tiny task. Examples can be for instance.

* Send email
* List contacts
* Scrape website
* Search the web
* Etc ...

When a software developer implements a use case, what he or she is doing is really just assembling fundamental building blocks such as the above into larger wholes, resulting in what we refer to as _"business logic"_. An entire industry has popped out over the last 50 years trying to smoothen the process of implementing business logic and use cases correctly.

> With AI, No-Code, and AINIRO, this entire industry is now obsolete

There is nothing magically occurring in this process though, and it can just as well be performed by an AI. To understand why and how, let's look at a video where I'm demonstrating how the AI can effectively replace the entire implementation phase of such use cases, by assembling smaller blocks together, to solve high level business requirements.

{% embed https://www.youtube.com/watch?v=PD0Wi67Wi2c %}

## The End of Software Development

I suspect that 5 years down the road, nobody serious about software development will actually write code anymore. There are only a finite amount of _"basic building blocks"_ we will ever need. The rest of the job will be orchestrating these smaller building blocks together, using natural language, to apply business logic, allowing the machine to autonomously fix the rest using AI. To give you one example, realise that in the above video, I took the following _"specification"_ and automatically transformed it into an AI assistant, capable of executing my task.

**Send marketing email**

```text
If the user asks you to send a marketing email, you will need to know what
contact to send it to, and which account the contact belongs to. Ask the
user what contact he wants to send the email to, for then to find the contact.
When you have the contact, you can use the contact's reference to the account
to find the account. When you know both the contact and the account, proceed
with scraping the account's website using the website URL you found from the
account, and create a personalised sales email trying to get the contact
into a meeting with us, to discuss AI Chatbots, AI Assistants, and custom
AI solutions, solving specific business requirements you anticipate the
company might have as you scraped their website. Create use cases relevant
to the account's verticals.

Show the email to the user, in addition to who you will send it to,
including the email address - But do NOT send the email before the user
has confirmed he or she wants you to actually send it.

## Additional information

1. To find the function required to scrape a website, you can use the
   "get-context" method and search for "Scrape website URL".
2. To find the function required to send an email, you can search
   for "Send email".
3. To find a contact you can search for "List contacts"
4. To find an account you can search for "List accounts"
5. Send the email from Thomas Hansen, CEO at AINIRO
6. Include a Calendly link to allow the user to book a meeting.
   The link is http://calendly.com/ainiro/ainiro-introduction
```

The paradox is that the above resembles every single use case I have ever seen in my professional life - And every single software developer ever having worked on a medium or large project have probably also seen thousands of similar use cases.

The idea is to create such use cases to create a formal specification for a software developer, leaving no room for misunderstanding, allowing the software developer to implement code that somehow solves the above problem. So creating such use cases is a skill we've become really good at over the last 50 years in the industry.

However, we can now completely skip the software developer, and move straight from use case to functioning software. In this process, 99% of all resources required to create working software has effectively vanished. As an additional bonus, what we're ending up with is not a traditional software system, but an AI Assistant you can write to using natural language, and even even talk to (soon!)

To understand why, realise the above use case example was simply copied and pasted into our VSS RAG database, resulting in a record in our database, that will be automatically transferred to OpenAI when the user says he or she wants to send a marketing email. This results in that **the use case becomes the software**!

> Basically, when you're done with writing down your use case, you're done implementing the software!

This results in a 1,000x better User eXperience (UX), where we're using our existing senses to communicate with the machine, and the machine autonomously executes some task for us such as illustrated in the above video. As an additional bonus, we can now take our eyes away from our phones, and interact with our software even as we're driving our cars by leveraging our voice.

> No need for AI driving our cars anymore, you can ditch your project Elon ... 😂

## The Trillion Dollar Bet

The software industry is worth trillions of dollars annually. Probably somewhere between 5 to 10 trillion dollars in total. My bet is that the _entire industry will completely collapse_, and be replaced by something completely different, where we're no longer interacting with our software using a graphical user interface, but instead our voice, and to a much less extent our eyes.

At this point the sceptics amongst you might claim I'm wrong, and tell me about the fallacies of existing initiatives like [Devin](https://devin.ai/), and maybe claim that even Devin and [GitHub CoPilot](https://github.com/features/copilot) at best are assistance tools for existing developers to make them more productive.

And yes, this is correct, but 99.7% of the world's population literally don't care about tools such as Devin and CoPilot. 99.7% of the earth's population cannot create software, they don't know any programming languages, and they literally don't care. All they want is a system that sends marketing emails, something that checks their emails and replies to their wife that they'll be late home from work today, or something that can book an airline ticket for them in May to go to Greece on vacation.

As software developers we've been _"shielded"_ from the above facts, while magically painting ourselves into our own little corner of lingo and abstract constructs, such as OOP, O/RM, DBMS, etc - In an attempt to simplify our jobs - While the end result became that we completely forgot our _purpose_, which is to create working software, solving requirements our _"customers"_ (99.7% of the world) happens to have.

> This is the reason why initiatives like Devin exists, because devs still believe it's about optimising the way we code - When the _real_ task at hand is to completely _eliminate_ the requirement for coding!

Do you think your grandma is going to wait for you to order her airline ticket because you're going to go prompt engineer Devin and have it produce a system that allows her to book an airline ticket? Of course not, or rather to be correct; Yes, maybe your grandma, but nobody else will bother to wait ...

## The future is No-Code and AI, not Devin or GitHub CoPilot

For us developers, Devin and GitHub CoPilot just might be the thing. For 99.7% of the world it's of zero interest. These 99.7% however though, can easily prompt engineer a couple of training snippets together, creating their own [AI workflows](https://ainiro.io/ai-workflows), that somehow solves their problems - At which point once you're done having Devin creating your _"airline booking system"_, they're already past that, having implemented an additional 1,000 AI functions, solving some 1,000 _additional_ problems for them - In addition to of course having perfectly solved the entire _"airline ticket problem"_.

> The future belongs to the illiterate, those without software development skills, the ones who don't give a sjait

Sorry guys, the party is over - You can all go home ...