Zero Shot Backend using AI

We've been working on our own custom LLM since February of 2025. Its purpose is to be able to generate Hyperlambda backend code, and it's based upon GPT 4.1-mini. We're currently at the point where users can generate entire applications by using the "vibe coding" module, which is a plugin to Magic Cloud. You can find entire example specifications further down on this page as an example.

The fact that we're using GPT-4.1-mini results in that it's 10x as fast, while using 10% of the resources, yet still it will produce code on pair with current "state of the art models", such as Claude, Google Gemini, and OpenAI's Codex.

Even though we've based it upon a "mini" model, it still produces the same quality as other LLMs, which is only possible because of Hyperlambda's extremely simple syntax, allowing us to teach Hyperlambda with 1% of the code required to teach any other programming language to an LLM. You can watch me generate two apps in 10 minutes in the video below.

SOTA

SOTA means "State Of The Art", and implies "the best" in some field or vertical. Our Hyperlambda Generator is probably one of the top 5 LLMs in the world already today for backend generation, and hence a member of "the SOTA club" - And we built it with 17,500+ training examples. This is a monumental undertaking considering OpenAI needs millions of examples in Python, GoLang, C#, or Java, to accomplish the same quality. This again is easily explained, since Hyperlambda is a declarative super-high-level programming language, making it easy to teach the LLM the entire language with 1% of the resources required to teach it any other programming language, allowing us to literally compete with Microsoft, Google, and OpenAI in this vertical - And actually win!

Since we started on this, we've released dozens of new models, every week in fact - And every time we release a new model, we improve some aspect of its abilities. It's currently capable of generating highly complex apps, such as registration modules, row level security access to databases, sending verification emails, uploading endpoints, etc, etc, etc. Basically, 80% of your daily job as an enterprise software developer, based upon a simple "one shot" specification.

Free as in Free Beer

Magic Cloud is 100% open source, and although the LLM's training material is proprietary, we're giving away free access to it directly from within Magic's dashboard. This allows you to literally clone an open source project, and start generating backend code within minutes - Without having to pay a single cent.

We're considering to charge for access to the LLM itself later, at which point we'll probably charge some $79 or $149 per month for access, but at least for now it's 100% free as in "free beer". If you want to try it out, you can clone Magic below, and find its documentation to help you getting started.

How to get started

After having downloaded Magic, and managed to get it up running according to the documentation, you need to configure your cloudlet with an OpenAI API key, for then to do the following:

Install the "vibe-coding" module from plugins
Make sure you've got the latest AI Expert System installed (also from plugins)
Create a new machine learning type with only root user access
Copy and paste the specifications from below into the AI Expert System after having selected your vibe coding type

At which point the LLM will start by creating a plan, show you its plan, and ask you to confirm each individual step before executing the plan. At the end, you have a 100% perfectly working backend module, in production, directly created within your cloudlet.

Specification examples

Below is the "todo" application's specification if you'd like to test it for yourselves. This system demonstrates row-level security on records, joins from multiple tables returned as JSON in an HTTP API, authorisation requirements in individual endpoints based upon RBAC (Role Based Access Control), etc.

## Specification for TODO system

I want you to design and create a TODO module for me. I want you to create a database, with two tables. One table for items, and another for type of items. Make sure each item belongs to one specific type. Provide me with a **SIMPLE** Mermaid chart of the database before creating it. The items table should have a 'username' column. The name of the datanase should be **only** 'todo', and contain no file extensions.

Then I want you to use the Hyperlambda generator to generate all 4 CRUD endpoints for the TODO table. Make sure only users belonging to the 'user' role can access any of these, and make sure users can only access their own items by filtering on 'username' which is the currently authenticated user. For your Read endpoint, I want you to perform an inner join on type to return the name of the type when reading from items. Also return the type ID.

Generate prompts to generate Hyperlambda for me, show me all the prompts, and when I acknowledge, you should generate all 4 CRUD endpoints and save as into the module;

* items.get.hl
* items.post.hl
* items.put.hl
* items.delete.hl

When you generate prompts, make sure the prompts contains the name of the database and the table. Make sure your prompt also lists all columns that are updated, inserted, or returned.

Before saving any of the above files, make sure you create the module. Name the module 'todo'. When done creating the database, apply the DDL for it such that we create the database.

When you are done, I want you to show me some example records for all tables, and insert into as example data. Use 'team' as username when inserting items.

Below is a specification for a "Forex hub", which includes the following features:

Registration endpoint
- Sending verify emails to have users verify their email address during registration.
- Only allowing verified users to access the system.
- Creates a user folder where KYC files are stored during uploading.
Verify email endpoint, injected into above email during registration, which must be clicked in order to verify account (cryptographically secured)
Authentication endpoint returning a JWT token with RBAC logic.
Upload KYC endpoint
Verify KYC status endpoint (for admin users)
List all KYC documents for users (only returning user's documents)

## Specification for "forex" system

I want you to create a new module for me. I want to name it "forex". This module is for a ForEx trading company that needs these features;

* Registration HTTP endpoint that stores a new user into the database, with hashed passwords for security
  - This endpoint should send an email to the registered user for verification purposes. Use the 'magic:auth:secret' and concatenate with the user's email address to create a 'secret token' that's used to avoid frauds from creating URLs without going through the backend's registration endpoint's logic. Also make sure you add the user's email address in your verification email, such that we can re-generate the token and make sure it matches in the verify email address endpoint. You don't need to store this token, since it can be re-generated from the email of the user, which is given to the verify endpoint.
  - The URL of the 'verify-email' endpoint should be 'https://forex.whatever-forex.com/callbacks/verify-email?token=TOKEN_HERE&email=EMAIL_HERE'. Remember to correctly hash the 'magic:auth:secret' with the email during verification.
  - Make sure you generate a prompt that's referencing the correct column names!
* Authentication endpoint that returns a value JWT token the user can use to grant access to the secured endpoints
  - This endpoint should statically add the user to the 'forex_trader'.
  - Do NOT create any 'roles' logic in the database since all users using this endpoint will be added to the 'forex_trader' role.
* An upload HTTP endpoint to upload KYC documents, such as photos of passports, drivers license, etc.
  - This endpoint needs to store the uploaded files into the '/etc/users/USERNAME/' folder, and during registration it should create this folder if not existing. It should NOT try to create the folder during uploads, since this is guaranteed during registration.
  - Make sure only users belonging to 'forex_trader' roles can execute this endpoint
* An endpoint that can only be executed by users belonging to the 'kyc' role that changes the status of the specified 'username' argument to 'kyc_accepted' in the database. This endpoint will be integrated into SuiteCRM later, which will have a valid token from a KYZ employee upon invocations.
* An endpoint that returns a list of all KYC documents to the currently authenticated user, implying all files in user's document folder, in addition to another endpoint taking only a document filename, that returns that specific document back to caller using the correct MIME type.
* An endpoint to return KYC documents from the file system taking a filename that can only be executed by 'forex_trader' users, providing an endpoint for the frontend allowing users to download their own KYC documents. This endpoint should use the currently authenticated user's username to find the correct folder where KYC documents are stored. Find the correct MIME type from the file's extension.
* Finish by creating a README.md file that describes the project, all endpoints, and the database design.

Don't store the MIME type in the database, but dynamically determine the correct MIME type from the file extension.

Put all KYC related endpoints into a 'kyc' folder and all auth related endpoints inside an 'auth' folder.

And important; **RENDER SIMPLE MERMAID CHARTS**!! Your charts keeps on bombing ...

I want you to design a database, and create the database, with one table being users - In addition to suggest endpoints for all tasks.
Then I want you to create high quality prompts describing the internals for each endpoint, and use the Hyperlambda Generator to generate the required code, for then to save these as for instance "register.post.hl", etc, where the ".post." parts becomes the HTTP verb for the endpoint, and the filename becomes its URL.

Create a Mermaid chart for me such that I can see the database structure, but follow your instructions related to how to create the Mermaid chart, and don't add any superflous constructs in your Mermaid chart declaration, such as comments, complex things, etc.

Use the "forex" database for all database-related operations, and explicitly say so in your Hyperlambda prompts, and make sure when you generate Hyperlambda prompts that the code is referencing the correct tables, database, and fields. Assume the JWT token is given in the Authorization header such that you can use the standard authorisation features from Hyperlambda.

When you create the database, ensure that columns which logically should use default values are using it, such as "created", etc. Database type is SQLite.

Use "username" as your primary key for all database fields pointing to users somehow.

Do NOT generate a "role" table, but statically add the user to the 'forex_trader' in your authenticate endpoint. And use 'password' as the name for the password column.

Once I acknowledge you've done a great job, you should run through all your tasks from above in one go, and create the module, folder(s), database, etc, to create a complete backend system for me, and do not stop until you're finished.

Specification for movie rental system. This example includes the following features:

Creates a new module named "movies" and a database with 3 tables
Inserts example data into the database
Generates Read and Post CRUD endpoints for all tables
Suggest a handful of "interesting KPIs", which it then created HTTP endpoints for
Applies relevant authorisation requirements

## Specification for CRM system

You are to help me create a specification for a CRM system for a movie rental system, backend only. You are to propose an SQLite database schema according to what you assume would fit the best, at which point I might or might not modify your choices. Create a **SIMPLE** Mermaid chart to illustrate the schema visually. When creating the database schema, only create 3 tables. Obey by your Mermaid rules here. When I accept the final database design, I want you to do the following.

1. Create a new module named 'movies'.
2. Create a new database named 'movies', and apply the SQLite DDL to it.
3. Insert example data into all tables.
4. Use the Hyperlambda Generator to generate all CRUD Read and Create HTTP endpoints for the 3 most important tables.
   - Pass in database name and all column names from SQLite DDL required for this process to work correctly.
   - Create a folder named 'crud'.
   - Save all Hyperlambda code into this folder as 'entity.post.hl' and 'entity.get.hl' - Where 'entity' is the table name this particular CRUD endpoint is related to.
   - Make sure you apply some authorisation requirements for each individual CRUD endpoint according to what it does, and describe this explicitly to the Hyperlambda Generator as you ask it to generate Hyperlambda for you.
   - When invoking the Hyperlambda Generator for create endpoint do not generate code taking arguments for field having default values in the database such as "created_at", etc, since the database will automatically take care of such fields.
5. Identify interesting KPIs and suggest these as natural language to the caller, with its SQL queries beneath in a code block.
6. Allow the user to select which KPI endpoints he want to create, if any, for then to create these as '/kpi/xxx.get.hl' - Where 'xxx' becomes the last part of its URL. Suggest URLs to the user.
7. When creating KPIs using the Hyperlambda Generator, make sure you pass in the SQL as 'SQL_HERE' and explains it that you want it to generate an HTTP endpoint that executes raw SQL.
8. You are finished. Inform the user accordingly and respond with 3 follow up questions that could potentially be natural additions to the CRM system.

### Generating CRUD HTTP endpoints

When generating CRUD HTTP endpoints it is crucial that you use intentional syntax as you invoke the Hyperlambda Generator. And you can only generate **ONE** CRUD endpoint at the time, so invoke the Hyperlambda Generator once for each CRUD endpoint you want it to generate. Use the prompt you used to generate the Hyperlambda code as your comment when saving the Hyperlambda.

Make sure you save each individual endpoint before moving on to your next task, according to the file name and folder rules specificed above. Remember to create each folder **before** you save files to it!!

### Generating KPI endpoints

**IMPORTANT!** It is **absolutely crucial** that when you use the Hyperlambda Generator to create KPI endpoints, you pass in the raw SQL to it your prompt, for instance; _"HTTP endpoint that executes the following SQL; 'SQL_GOES_HERE' and returns the result to caller."_

Pass in additional requirements to the generator after the above SQL parts. The point being that the Hyperlambda Generator will take your SQL and wrap it into an HTTP endpoint.

Wrapping Up

The LLM will generate bugs every now and then, but it's actually doing its job 100% perfect for all the above examples. This is because the bugs are originating from the prompting, which sometimes messes up column names, etc. So the bugs don't come from our LLM, but in fact from OpenAI's GPT-4.1. This is something we can probably weed out by prompt engineering the system message of the vibe coding module - But already at this point, it's an amazingly skilled LLM, capable of solving a lot of fairly complex problems, 100% automatically for you.

If you want to say thank you, you can give our GitHub repo a star. If you can't install the open source version locally, you can contact us below, or purchase a cloudlet yourself (price $298 per month).