MemoGo: Go Beyond Prompts

MemoGo is Memocule’s declarative programming platform, built on a universal runtime shared across all systems and customised using simple, structured configuration files. Think of it like the Java Virtual Machine (JVM): one engine, many apps each defined by its own clean, modular configuration. Instead of relying on natural language prompts or sprawling codebases, MemoGo turns application logic into data, which is clear, precise, and ready for both human developers and AI collaborators.

Code is the UI

There is a common view that code is just a means to an end. This "vibe coding" mentality often leads to a patchwork of LLM-generated snippets and a growing mountain of technical debt. However, this perspective fundamentally misunderstands the purpose of code. Code's job is not just to tell a computer what to do; it is also the primary interface for programmers to reason about and manipulate a living, constantly changing system. It is the pilot’s cockpit, providing both a joystick for precise control and a dashboard for critical feedback.

As desirable as it would be, we don’t believe it’s possible to democratise programming by simply swapping a specialised language out like Java for a natural language like English. Natural language lacks the economy and precision required to avoid logical inconsistencies and anticipate all scenarios. Programming languages exist for the same reason mathematicians and musicians use specialised notation, expressing complex ideas with clarity and an absolute minimum of ambiguity. What makes programming complex is being able to anticipate all scenarios and avoid logical inconsistencies. We know this, because it’s been tried many times before. In the 90’s, 4GLs and modelling languages such as UML were all the rage, but went nowhere. Syntax was never the problem and using an imprecise natural language merely disguises rather than solves the problem.

The closest modern day analogies to this domain specific declarative language approach are HTML, CSS and SQL. It’s both noteworthy and not a coincidence that these languages are usable by many more semi-technical people than full-blown languages such as Python.

One misconception, shared by business and technical alike, is that creating software is a finite task - something like writing a book. Indeed, the very use of terms like “writing software” implies it’s something with a beginning and an end. Sure, typos get found out, and authors diligently revise their manuscripts, but what never happens with text is for someone to come along and say “Tale of Two Cities is great, but we need to include a third city”, and then the week later, “BTW, forgot to mention, but we need to swop out Paris for Barcelona”. Followed up with a “Hey, can we integrate 'Down and Out in Paris and London’”.

A related misconception is that software maintenance is bug fixing. Again, the very term “maintenance” makes you think of taking your car in for a service. But no one ever asked “Can you make it a convertible whilst you’re at it”, nor exclaimed “Sorry, we need it painted blue now”, or “Actually whilst the blue is good, can we swop out the interior for cream leather?” Bugs exist and need to be fixed, but that is not the primary reason we don’t fire the engineering team after the first release. When will it be finished? Never.

MemoGo addresses this challenge head-on by providing a declarative, data-driven solution. Instead of wrestling with a complex, hard-coded codebase, developers describe the application's data model and views using simple, precise JSON files. This approach embodies the principle of "code as data," where the configuration itself becomes the highly specialised, unambiguous language programmers use to "fly" the application. This idea of code as data is hardly new, being the foundational principle of LISP in 1958, the world’s second oldest high level programming language, just pipped to the post by FORTRAN in 1957.

MemoGo's Data-Driven Solution

MemoGo abstracts away the complexity of continuous change by shifting the focus from imperative coding to a declarative configuration. It uses a model file to define the entire data structure and an analogous view file for the application's appearance.

Declarative Data Model

The model file defines each entity and its attributes. By using a structured language like JSON, MemoGo forces developers to confront logical inconsistencies and think through the data model upfront, which is where the real value of programming lies. This declarative approach allows the application to be generated automatically, reducing boilerplate and embodying the principle of "Don't Repeat Yourself" (DRY) in a way that is fundamental to the architecture.

A New Kind of Modularity

MemoGo embraces the idea that a programmer's primary job is to create versatile components, not monolithic models. The JSON configuration serves as a blueprint for assembling and re-assembling these components. This approach enables a form of meta-programming, where the configuration itself is the data that generates the final application. This not only democratises the process but also makes the system highly adaptable to future changes, as new functionality can often be achieved by reconfiguring existing components rather than rewriting code. Crucially, this allows custom app development to be done by professional services staff with domain expertise, rather than requiring software engineers.

The Role of AI with MemoGo

This data-driven approach is not only ideal for human developers but also for artificial intelligence. We believe LLMs are not a replacement for programmers, but powerful tools that can dramatically increase productivity—akin to "next level linting and Stack Overflow search." The challenge with most AI-assisted programming is the ambiguity of the natural language interface. Trying to generate a precise application from an imprecise English prompt will inevitably lead to logical holes and inconsistencies.

MemoGo solves this by providing a highly structured and unambiguous interface for AI. The JSON configuration in model and view is a machine-readable language that precisely defines the application's components and their relationships. An AI can consume this data, reason about it, and generate new configurations or manipulate existing ones with a level of precision that is impossible with natural language. This moves the AI's role from "vibe coding" to a more powerful, structured collaboration. It can help consultants and programmers quickly scaffold new applications by generating the initial configuration, or assist in modifying and extending existing ones, all while ensuring logical consistency.

Conclusions

By combining the declarative power of MemoGo with the distributed resilience of MemoConductor, we are creating a new way to build applications that sidesteps the limitations of visual programming and natural language prompts. This approach enables:

Rapid Development

Inherent Scalability and Availability

Precision and Consistency

MemoGo and MemoConductor are more than just a set of tools; they represent a fundamental shift in how we think about software development. By moving from a codebase-centric approach to a data-driven one, we can build the next generation of responsive, scalable, and collaborative applications.