This paper explores self-updating and self-fixing software, harnessing AI and innovative platforms based on NoCode super app builders. Trust emerges as a central theme, especially in autonomous software changes. To ensure reliability, we employ rigorous testing and blockchain-based verification. While technology advances, the enduring need for human trust remains at the forefront.


SwissCognitive Guest Blogger: Ivan Assenov – “The Evolution of Software: AI, NoCode, Blockchain’s Disruption of Traditional Programming”


In the modern era, traditional programming touches nearly every aspect of our lives, whether it’s through our work, the games we play, or the apps we use daily. Over the past 75 years, software has become ubiquitous, but it’s also gained a reputation for being notoriously buggy and expensive. This imperfection, combined with the high costs and time involved in creating software — especially at the enterprise level — means many software products struggle to maintain profitability despite their popularity. With consumers constantly seeking more for less, the software industry is in a cycle of relentless reinvention. The past decade has brought forth three revolutionary trends poised to redefine the landscape: NoCode/LowCode development, artificial intelligence, and blockchain. In this article, we’ll delve into how these three innovations, working in tandem, might shape the future of software.

If we break down a software cycle today on a very high level, it usually consists of having some requirements, some developers writing some code, then deployment is done and the software is available for use by the end users. There is so much more to this cycle known in the software industry as SDLC – Software Development Life Cycle but in a nutshell, it is not that complicated. And yet, tens of thousands of books had been written, certifications had been issued, and whole divisions in the corporate world had been devoted to dealing with the side effects of how software functions or malfunctions. From cybersecurity, compliance, DevOps, agile coaches, and scrum masters, a massive amount of cash is injected to keep the machine floating in order to sync all sides.

What if we are to optimize all of this chaos with a few simple steps that will fundamentally transform how software is written, maintained, and distributed?

Self-tuning software and self-releasing software

As the digital realm evolves, the demands on software grow exponentially. Picture a world where a software product, be it a sophisticated website or an engaging mobile app, has a high daily active user (DAU) count and the innate capability to evolve independently. What if this software could automatically optimize itself to enhance its DAU and /or Average Time on Page(ATP), enact AI-driven fixes, and autonomously deploy updates? The claim below is that such a vision is achievable through the combined prowess of AI, NoCode, and Blockchain.

To truly grasp this vision, let’s delineate its elements:

Thank you for reading this post, don't forget to subscribe to our AI NAVIGATOR!


  • We aim to amplify already operational software, not start afresh.
  • The primary goal? Boost the DAU/ATP, potentially by refining the user interface or tailoring user experiences.
  • All modifications are AI-driven, ensuring adaptability and responsiveness.
  • These changes are not just theoretical; they are auto-deployed to the live environment in real-time.
  • Users remain at the forefront. Their experience is seamless, undisturbed by the ongoing evolution.
  • Finally, and most crucially, every autonomous change is TRUSTED, guaranteeing both functionality and security.

Diving deeper, we will explore how AI, NoCode platforms, and the immutable nature of Blockchain technologies can make such a futuristic vision a reality.

Below we will go over each one of them using AI, Nocode, and Blockchain technologies.


For software to truly be self-evolving, its origin is pivotal. It should be constructed using a leading-edge NoCode super app builder platform, complemented by its unique declarative language. Such a foundation heralds an age where software is not just functional but is also learning and adapting in real time.

For the system’s initial setup, human intervention will be crucial to fine-tune the preliminary system prompts. This hands-on approach will be maintained for the initial thousands of iterations to ensure optimal performance.

Enhancing DAU and ATP through UI automated Adjustments

The synergy of machine learning and generative AI holds immense potential in our mission to elevate the user experience. By weaving these AI technologies into metrics that evaluate DAU/ATP, site performance, and user interactions, we can incrementally perfect the user interface to resonate more deeply with users.

Let’s visualize a fundamental webpage design: it comprises a label, some text, and a button. Over successive releases, subtle modifications, be it in their positioning, color schemes, default settings, or shapes, are introduced. The ramifications of these changes on user engagement are then meticulously analyzed.

What sets this system apart is its foundation in NoCode. This means that the incorporation and fine-tuning of these elements can be actioned through APIs. Adding a layer of sophistication, the system has the capacity to roll out varying UI layouts across distinct geographical locales, thereby evaluating the sway of regional and cultural nuances on user behavior. With continuous feedback, the system hones in on an interface configuration that garners maximal user traction.

Each interaction a user has — ranging from the duration spent on tasks to the nuanced patterns of cursor or finger movements — is documented. When this treasure trove of data is aligned with its respective release version, it provides invaluable insights. It’s pivotal to implement the Semantic versioning approach, typified by its trio of numerals, ensuring smooth tracking and management of these iterations. For a seamless experience, it’s imperative that every integrated plugin or mini-app conforms to this versioning framework.

At the heart of the initiative lies the profound capabilities of AI. For us to realize seamless automation of these alterations, it’s vital to synchronize our Language Learning Model (LLM) with the API overseeing the creation and refinement of mini-apps within the NoCode super app ecosystem. To bolster the quality and range of the data, a strategic move would be to roll out diverse versions across multiple regions or user demographics. This would furnish us with a broad spectrum of data, enabling sharper insights into patterns of progression or setbacks.

Addressing the crucial aspect of security and privacy, there are a couple of pathways we can tread. The Retrieval-augmented generation (RAG) system offers one solution. Alternatively, a privately hosted LLM stands as another viable choice. By incorporating a dedicated embedding API interfacing with a vector database, we can assure the continuity of data updates. Currently, the accessibility of RAG is commendable, with numerous providers extending generative model services. Merging these with embedding functions and vector databases becomes a relatively straightforward task. For entities operating on leaner budgets or those with distinct requirements, more rudimentary machine-learning models are available, though they might lean more heavily on manual supervision. On the flip side, a privately hosted LLM could be an ideal fit for expansive enterprise networks that can bear the accompanying expenses.

Equipped with this newfound flexibility in deployment decisions, it’s crucial to recognize the looming challenge: maintaining trust. With every new change introduced, the overarching question remains—how will these alterations serve real-time users, especially if the entire operation is expected to function without human intervention?

There could be a few steps we need to establish:

Instead of simply recording primary events like clicks, scrolls, or page navigations, we advocate for a deeper capture of interactions. This should encompass touch actions on mobile and mouse actions on desktop, stored in a consistent key-value pair format. For instance:
{ “eventType”: “click”, “elementId”: “button123”, “timestamp”: “2023-10-06T14:30:00Z”, “location”: [x,y] }.

  • Textual Interpretation: Transform the structured key-value pairs into user-friendly textual descriptions. Using our earlier example, this might read as:
    “The user clicked on button123 at coordinates x,y.”
  • Text Embedding: Utilize Natural Language Processing (NLP) models such as Word2Vec, FastText, or even sophisticated variants like BERT to generate embeddings from these textual insights.
  • Vector Database Storage: Archive the created embeddings in a vector database, making sure they’re aptly indexed for swift retrieval.
  • AI-Driven Search Optimization: Employ AI to sift through the saved embeddings, pinpointing patterns from prior interactions. This enables the system to bolster positive user experiences or adjust in cases of identified regressions.
  • Feedback Loop for Continuous Enhancement: Introduce a feedback mechanism, consistently fine-tuning and retraining the system, ensuring an ongoing refinement in user interaction capture and interpretation.
  • Human Oversight: While the emphasis is on automation, the importance of human monitoring, especially in the nascent stages, cannot be overstated. It guarantees that system optimizations align with intended outcomes and maintain a human-centric approach.

Once all components are seamlessly aligned, a critical element remains for our autonomously managed and deployed model: establishing TRUST. Users need the assurance that the software autonomously deployed is not just operational, but is precise, unbiased, and safe.

Before delving into the process of establishing trust, let’s first discuss code coverage, an integral aspect that subsequently ties back to trust. Among the multitude of code coverage types (more than 15), Statement Coverage (C1) and Branch Coverage (C2) stand out as the most prominent.

Statement coverage assesses whether every code line has been addressed at least once during automated testing, while branch coverage evaluates how many control branch pathways (like ‘if’ statements) have been executed.

Today’s developers may only intermittently apply these tests, and even then, not to their fullest extent, leading to incomplete and outdated tests over time.

For genuine trust in automated releases, we must:

  • Ensure that both prevalent code coverage types are extensively addressed.
  • Independently verify that this coverage is trustworthy.

To accomplish this, we propose leveraging certified public blockchain transactions to log actual runs of C1 and C2 tests, introducing two levels of assurance: Level 1, where both C1 and C2 are 95% or higher, and Level 2, with both C1 and C2 at a full 100%.

It’s imperative that the chosen blockchain be public, affordable (costing mere thousands of pennies), adhere to the foundational Bitcoin protocol, and make no compromises. Currently, only a handful of blockchains meet these standards. This means in the future a new blockchain must be created to suit these activities.

Access to unit tests should be granted at the Blockchain node levels, accommodating those keen on mining blocks. Moreover, the declarative language fueling the NoCode platform components and plugins should be fully open-source. Furthermore, plugin codes derived from this declarative language should be accessible to miners upon registration.

Envision a scenario where every plugin, NoCode element, or mini-app possesses a certification indicating its trust level. This blockchain could either store the certification’s hash or its entire content sourced from the tests.

Below is an example of such a structure

Merging these components results in an autonomous system — externally observable, yet internally equipped and self-reliant to execute requisite tasks. As the digital realm undergoes swift metamorphosis, the bedrock of trust remains unshaken. While our drive for flawless automation is commendable, it should not eclipse the users’ innate need for reliability and security. Marrying meticulous testing methods with blockchain’s unwavering transparency, we transcend beyond just delivering software; we promise serenity. Poised at this technological precipice, our forward gaze is filled not just with eagerness but an unwavering pledge to honor the trust.

In this era dominated by code, the essence of trust remains inherently human.

About the Author:

Ivan Assenov‘s mastery of NoCode/LowCode has impacted hundreds of millions in the financial domain. Combining insights from high-frequency trade transactions with blockchain and generative AI systems, he stands as a software visionary.