The Short Answer
Code Mode turns one prompt into a scaffolded Next.js application — components installed, dev server running — and the output is a codebase in your own repository rather than an app hosted on a vendor's platform. On ibl.ai you own all the code and the data, run it model-agnostic across any LLM, and pay with no per-seat pricing, so you can deploy anywhere from your own cloud to an air-gapped network.
Agent Skills ship alongside it: reusable playbooks any agent loads on demand, versioned as files in the repo.
What does Code Mode actually produce?
A prompt goes in; a working Next.js application comes out — project scaffolded, dependencies resolved, components installed, and the development server running locally.
The distinction worth drawing is between generating an app and generating a codebase. Many AI builders produce an application that lives on the builder's platform: you interact with it through their runtime, extend it within their constraints, and host it where they host it.
Code Mode writes source files. What you have at the end is a standard Next.js project — same structure a developer would create by hand, same deployment story, same ability to open it in an editor and change anything.
What are Agent Skills, and why do they matter here?
An Agent Skill is a file describing a procedure: the sequence of steps, the tools involved, and the guardrails around them. Agents load skills on demand rather than carrying every procedure in their context window.
Two properties follow from being files rather than prompt text:
- They are reusable. The procedure for "scaffold a service the way this organization does it" is written once and loaded by any agent that needs it.
- They are reviewable. Skills are versioned, diffed, and code-reviewed like any other artifact, instead of living as prompt fragments pasted between sessions.
That second property is what makes them usable in a regulated environment. A procedure in version control has an author, a review, and a history. Prompt text in a chat has none of those.
How is this different from a hosted AI app builder?
The difference is what you hold at the end.
| Question | Typical hosted builder | Code Mode |
|---|---|---|
| What is the output? | An app on the vendor's runtime | A Next.js codebase in your repo |
| Where does it run? | Vendor cloud | Anywhere you deploy — incl. air-gapped |
| Which model? | Whichever the vendor chose | Any LLM, swappable |
| What if the vendor goes away? | The app goes with it | The code keeps building |
| Pricing shape | Per seat or per app | Usage-based or flat license |
Does generated code belong in an enterprise codebase?
Only under the same conditions as any other code — which is precisely why the output shape matters.
Generated source can be read, linted, tested, and reviewed before it merges. Generated applications on a vendor runtime often cannot: there is no diff to review and no build to reproduce.
The scaffold Code Mode produces is deliberately conventional. It uses the framework's standard structure rather than a proprietary abstraction, so a developer who has never seen Code Mode can maintain the result. The measure of a good scaffold is that it becomes invisible.
The underlying toolkit is open source under MIT at github.com/iblai/vibe, and Agentic Vibe covers the full scaffold — SSO auth, AI chat, profiles, and analytics wired in, shipping to web, desktop, and mobile from one codebase.
What does this change about build-versus-buy?
It narrows the gap that made buying attractive.
Building internally lost on time-to-first-version: months of scaffolding before anything demonstrable. Buying won on speed and lost on ownership — a subscription, a vendor's data boundary, and a per-seat bill scaling with headcount rather than usage.
Compressing scaffolding from months to minutes removes the reason to accept the second trade. You get the speed of buying with the ownership of building.
The cost shape is the other half. Per-seat AI tooling bills whether or not it is used — ChatGPT Enterprise around $60 per user per month, Microsoft 365 Copilot around $30 — so a 5,000-person organization pays roughly $3.6M or $1.8M a year before anyone ships anything.
That only holds if the generated artifact is genuinely portable. An app you produced quickly but cannot self-host, audit, or migrate is not something you built — it is something you rented faster.
The ownership questions in who owns your data when you use AI apply to generated applications exactly as they do to generated text.
Can Code Mode run OpenAI Codex or Claude Code instead of ibl.ai's own agent?
Yes. Code Mode runs on one of three coding agents, chosen from the Agent control in the Code panel: ibl.ai, which is built into the app and is the default, or Codex, or Claude Code.
The part worth reading twice is what those two are not. Per the Code Mode documentation, Codex and Claude Code "are not models we host; they are the vendors' own coding agents, run on your own subscription."
So switching the agent does not add a second bill. Code Mode becomes a front end to a tool the organization already pays for, which is a different procurement question from onboarding another vendor.
Two practical limits that the announcement version of this story leaves out. Each agent is installed and signed in outside the OS: for Codex, in the ChatGPT app; for Claude Code, by running claude in a terminal.
And the choice is held per machine, not per account, deliberately never synced, because an install and a CLI login are local facts about the computer you are sitting at. On another machine, Code Mode is back on ibl.ai until you choose again there.
A Code agent model picker then appears in the agent's top bar for whichever agent is selected, defaulting to Default, meaning the agent's own choice of model.
Codex's list comes from the Codex CLI's own model inventory, so it reflects what your subscription actually grants.
That is model-agnostic applied one layer up: not only which LLM answers, but which coding agent holds the loop. Whichever you choose, the scaffold still lands in your repository.
Can Code Mode build an app that takes payments?
It can scaffold the application, and the payment rails are a separate documented platform feature rather than something one prompt wires up end to end.
Worth keeping those two apart, because collapsing them overstates what ships today. Code Mode scaffolds and runs an application from the chat box, building on the Agentic Vibe starter, with every tool call gated behind an explicit Allow or Deny.
Monetization is configured at the organization level. Monetization runs Stripe Connect onboarding first, then paywalls: pick the item to sell, set its pricing, and choose a grandfathering policy for pre-paywall users (Free Forever or Require Subscription).
Until Stripe onboarding completes, the paywall area stays disabled with the message "Connect Stripe first to configure paywalls," and the status badge reads Not Configured, Incomplete, or Configured.
So the accurate sequence is scaffold, then connect, then paywall: three documented steps inside one platform, not a single prompt to a live paid product.
The ownership claim survives that correction intact. The application is a codebase you hold, and the Stripe account receiving the money is yours.
Where ibl.ai fits
ibl.ai is the agentic AI platform where you own all the code and the data.
You self-host the entire stack inside your own perimeter, run it model-agnostic across any LLM and switch anytime, and pay by usage with no per-seat pricing — so you can deploy anywhere: your cloud, on-premise, GovCloud, or fully air-gapped.
Code Mode and Agent Skills run on that platform, which is why the output is a codebase rather than a tenancy.
1.6M+ users across 400+ organizations run the platform this way, including NVIDIA, MIT, and Syracuse University.