Humans structure. AI interprets.
Kubbler is not one more code generator. It is a foundation designed, written and operated by engineers (the code that structures every product and makes your creations possible) and an AI with one precise role: interpreting your intent to assemble it on top. Humans set the grammar; the AI speaks your language. That is what makes the AI useful, and harmless to your foundations.
- capabilities written by hand by engineers
- 22capabilities written by hand by engineers
- interface blocks designed and reviewed by humans
- 81interface blocks designed and reviewed by humans
- of the foundations written, never generated
- 100%of the foundations written, never generated
The engineers
They structure the code: architecture, security, payments, data, deployment. They write, review and operate the foundation everything rests on.
The AI
It interprets: it translates your intent into screens, data and journeys, from what already exists. It reinvents nothing that has to hold.
You
You decide: your trade, your rules, your brand, what goes live. Nobody knows your market better than you.
AI is a remarkable interpreter. It is not an architect.
The public debate pits two caricatures against each other: the AI that would replace developers, and the AI that should be kept away from any serious code. We subscribe to neither. We have been building software for years, and we use AI every day. What we have learned is simple: it is extraordinary at interpreting: understanding an intent expressed in plain language, translating it into a given vocabulary, proposing variants, adjusting a tone. And it is dangerous when asked to architect, that is, to invent, for every project, the foundations engineers spent years hardening.
An interpreter does not create the language they work in. They know its grammar, its vocabulary, its usage, and they respect them. That is exactly the role Kubbler gives the AI. The grammar is the foundation's conventions. The vocabulary is the 81 interface blocks and the 22 capabilities (accounts, payments, data, security, deployment) written by hand by our team, reviewed, tested and run in production. The AI composes with that vocabulary; it does not step outside it.
This line is not a posture: it is built into the product. The AI works on the product layer (your screens, your copy, your data model, your journeys) and never on the foundations. What it produces is checked before being saved. Whatever touches security, payments, migrations or going live is code humans wrote, humans maintain, and humans answer for: to you, to an auditor, to a customer.
We believe this is the only honest way to use AI to build software that has to hold. It makes creation accessible to those who don't write code, and it makes engineers faster. But it is humans who structure the code, who make those creations possible, and who take responsibility for their quality. The AI is the interpreter between your intent and that foundation. Nothing more, and that is precisely what makes it so useful.
Humans set the grammar. AI speaks your language.
Two roles, one sensible split.
The question isn't "AI or humans". It is: what do we hand to the interpreter, and what do we refuse to hand over.
What structures, and has to hold
What it interprets better than anyone
How the AI works at Kubbler.
Four rules that make it a reliable interpreter, not an improvised architect.
It translates, it doesn't invent
Your description becomes pages, fields and journeys. The AI chooses, configures and dresses; it rewrites neither authentication, nor payments, nor the database. Those bricks exist before it.
A finite vocabulary, written by humans
81 interface blocks and 22 capabilities, designed, reviewed and operated by our team. Every word the AI uses was written by someone who can answer for it.
A grammar it respects
The foundation's conventions (structure, validation, security, naming) frame everything it produces. The result is code a developer recognises, reads and can take over.
Work checked before it's kept
What the AI assembles is checked before being saved into your project: it has to build and follow the conventions. And nothing goes live without you having seen it in the preview.
Why AI alone always stops at the same place.
These aren't edge cases: it's the wall every fully generated project hits, usually at the exact moment it starts to work, and the reason we refuse to hand it the foundations.
Code nobody understands
A running demo is not a product. At the first incident you need someone who knows why that code exists and how it holds, and when everything was generated, there is nobody.
Improvised foundations
Patched-together login, API key in the browser, database with no migrations: precisely the places where an approximation doesn't show right away, and is paid for in leaked data.
Invisible debt
Every prompt adds code nobody reviewed. A model that rewrites a security layer for every project produces different vulnerabilities for every project. It doesn't show right away. It never shows at a convenient moment.
And then, going live
Generating a page is easy. Domains, certificates, backups, secrets, compliance, on-call: that is another trade, it can't be improvised, and no prompt replaces it.
Who does what, at every step.
The split isn't a posture, it's built into the product. Here is exactly where the line runs, from the first word to going live.
You describe
Your words, your trade, your rules, your brand. Nobody knows your market better than you, and no model is going to guess it. You refine through the conversation, you point at what has to change.
The AI interprets
It translates your description into screens, data and journeys, drawing on the foundation's vocabulary, never reinventing the foundations. It proposes; you see the result live.
The engineers structured
Accounts, payments, security, migrations, going live: code written by hand by our team, reviewed, tested, already in production for other customers, and fixed for all at once. That is what makes your creation possible.
You adjust, then you publish
On screen, live, until it is exactly right. Then one click: domain, HTTPS and backups included. You remain the person who decides what goes live.
What this split guarantees you.
Four very concrete consequences, verifiable on your first project.
Your code belongs to you
Exportable to GitHub, readable, conventional JavaScript. No black box, no proprietary format, no dependency on us to keep going: a developer picks the project up as is.
Foundations are not guessed
They are written once by engineers, reviewed, and serve every project. What gets fixed here is fixed everywhere, including in your product, without you having to think about it.
Humans behind it
A team of engineers, in Paris, who answer, fix and grow the foundation. No AI has ever carried a pager at three in the morning, or answered for a breach in front of a customer.
The AI's mistakes are cheap
Because it only touches the surface, an AI mistake is a line of copy to revisit or a misplaced block, visible in the preview, fixed in a sentence. Never a security hole or a double charge.
AI takes care of the surface, never the foundations. That is the difference between a pretty demo and an application that is actually yours.
The questions we get asked.
About the line between AI and humans, and what it changes for your product.
On the product layer, yes: screens, copy, layout, data model, journeys, within the foundation's conventions. Never on the foundations (authentication, payments, security, migrations, going live) which are code written and reviewed by engineers, shared by every project. What it produces is checked before being saved.
Async Code's engineering team, in Paris. The foundation is fixed and extended for every project at the same time: what gets repaired for one is repaired for all, including yours, with no action on your part.
Because that is what it actually does here. A generator invents new code with every request, foundations included. An interpreter works within an existing language (here the 81 blocks, the 22 capabilities and the foundation's conventions) and translates your intent into it. The distinction isn't rhetorical: it is what avoids the wall when it's time to go live.
It gets the surface wrong, never the foundations: a line of copy to revisit, a misplaced block, one field too many. You fix it live in the preview, or in a sentence. Nothing touching security, payments or data goes through it, which is precisely what makes a mistake cheap.
Yes. It's readable, conventional JavaScript, and exports to GitHub at any time. The backend runs in Paris on Scaleway, the frontend is served from Cloudflare's edge, and you judge for yourself, with or without us.
Not here, and we don't believe so. It makes creation accessible to people who don't write code and makes developers faster on what doesn't set them apart. But structuring a foundation, securing it, operating it and answering for it remain human work. We built Kubbler around that conviction.
The best of both, without the worst of either.
Free during the beta, no card required. Describe your product and watch where the AI stops, and where the engineers' work takes over.