App Composer briefing
What happens between having an idea and running a project you can keep improving?
Generated by NotebookLM from our completed product vision. The examples and figures illustrate that vision. App Composer is independent.
From Idea to Operation
A visual walkthrough of the path from a brief to a working project you can return to and improve. 6 min 41 sec
Read the full transcript
Automatic transcription with product names corrected.
0:00 The work around an idea
Okay, let's jump right into this explainer and tackle a problem I'm sure every single creator out there knows all too well. That massive, frustrating gap between having a brilliant idea and actually owning a fully operational project. If you've ever tried to build something online, you know that the initial spark, well, that's the easy part. Today, we're zeroing in on the core mission of App Composer, and specifically, how it completely bridges that gap to take you from a raw concept to something you actually own and operate.
Okay, so really think about it for a second. What actually happens between having an app idea and getting a usable result? Let's be honest. We all have that hidden folder of half-finished side projects or, you know, that graveyard of abandoned GitHub repos, right? Writing the code is so often treated as the main event, but for independent developers and small businesses, it's honestly just a fraction of the battle.
It's that whole lifecycle of connected tasks around the code where most projects just kind of stall out and die. The incredibly disconnected chaos of app creation. You've got planning, writing the software, design, media production, account setup, and deployment. It's a lot. The central friction here is the sheer amount of disconnected work. Every single time you switch tools or hand off a task, you lose vital context.
You might have this absolutely brilliant code base. But if your deployment accounts aren't configured, or your media assets are sitting in a totally different system, you don't have a product. You basically just have a pile of disjointed parts.
1:29 The App Composer mission
Which brings us squarely to App Composer's core mission. And the goal here is surprisingly grounded. To make it simple for people to create, own, and improve useful projects. All with sound engineering underneath. Now, the words useful and ownership carry some serious weight here. We're not just talking about generating some flashy, throwaway AI code that breaks the second you look at it funny.
No, it's about delivering a functional result. Maybe a tool that actually saves a business administrative time, or helps an artist release their music. That belongs entirely to you. It's really fascinating to see how this mission aligns two totally different worlds. On one side, you have the customer's mission. You just want to easily build and own your work. Simple enough.
On the other side, you have Cloudflare's infrastructure goal, which is driving meaningful adoption of Cloudflare Workers and Workers AI. App Composer acts as the perfect bridge here. You get a highly capably manageable application, and under the hood, it organically drives the adoption of this incredibly powerful infrastructure. It's this perfect synergy where the tool gives you exactly what you need while quietly building on top of world-class routing and hosting.
2:34 From outcome to publication
So chronologically, turning a raw brief into a working result takes a highly specific path inside Composer. First, you start with an outcome, describing your idea or bringing in some references. Then the Get Ready phase steps in and completely removes all that setup anxiety by checking your environment for you. Next up is in it, which actually translates your brief into a hard, usable specification.
From there, an agent builds the missing pieces for you to inspect. And finally, you publish it to an owned destination. It's a perfectly guided path that literally removes the expectation that you need to be some sort of DevOps expert on day one. But here's the thing.
3:11 Coming back to change it
The first AI generation is really just the starting line. The true magic happens when you inevitably return to the project to make changes. I mean, think about how frustrating it is when an AI tool casually overwrites your hard-earned customizations just because you asked it for, say, a button color change. Composer completely prevents that. Your project identity, your accepted designs, and existing records all remain perfectly connected.
When you ask an agent for a revision, it actually preserves your original intent. That means your project can survive ordinary mistakes and adapt over time without just erasing your history. You should be able to make a useful thing without first learning how to run an internet company. I love that. It so perfectly grounds all this abstract technical infrastructure into a highly relatable benefit.
You shouldn't have to become a systems engineer just to launch a personal website, an interactive game, or a small business tool. Composer basically absorbs all that surrounding friction, so you can focus purely on whether the result is actually appropriate and useful for your audience.
4:11 Owning the source and data
Let's dig into what true ownership actually means for a second, because it's the ultimate antidote to vendor lock-in. True ownership means you can pinpoint exactly where your application runs. You have the actual source code, you retain all your editable assets, you understand which accounts it uses, and most importantly, you can operate it entirely independently.
You aren't just renting some simulation of an app from Composer. You possess the real functioning machinery and the database. Composer absolutely does not act as some hostage-holding runtime dependency forever. You literally have the freedom to take your code and go whenever you want. Now, to guarantee that high level of ownership, Composer relies on a uniquely strict benchmark for success,
4:48 What counts as finished
built around six incredibly demanding gates that act as a stress test. These test technical checks, creative judgment, and actual real-world operation. It has to be a useful app, finished in its presentation, accurate to its claims, genuinely published with real distribution, capable of continued operation, and finally, something you are actually proud to share.
You can't just pass one of these. A beautiful interface doesn't rescue a broken backend, and a perfect backend means absolutely nothing if the interface is unusable. It demands the whole package. To ground those benchmarks in reality, let's look at what Composer is already powering today.
5:32 Examples from the portfolio
There are real, highly useful mini-apps out in the wild right now. You've got Paperwork, which handles local PDF markups and exports. There's LDraw, providing an editable diagramming workspace where humans and AI share the exact same scene model. Here / there is a super cool moderated guestbook for collecting photos safely. And of course, Hello World as a setup proof.
These aren't just isolated flimsy tech demos. They are functional, real-world tools actively contributing tested methods back into the Composer ecosystem, them, proving that this core mission actually works in practice. We've covered a whole lot of ground today exploring how App Composer transforms the massive friction of development into a unified, truly owned project.
But I want to leave you with this final provocative thought, which is really the ultimate stress test for any AI-assisted workflow. Would you proudly share the delivered result under your own name without having to dive in and repair the code or fix the assets yourself? That right there is the exacting standard composer is built for, empowering you to turn a raw, brilliant idea into a lasting operational reality.
Listen
From AI Prompts to Production Software
A conversation about ownership, getting a project running, and the handoffs that matter after the first build. 26 min 47 sec
Read the full transcript
Automatic transcription with product names corrected.
0:00 The creator’s trap
You know the exact feeling, right? You're, I don't know, in the shower or maybe you're stuck in traffic and boom, it hits you. The million dollar idea. Exactly. The brilliant idea for an app or a game or like maybe a tool that would finally organize your chaotic neighborhood community board. Oh yeah. We've all been there. Right. So you get this surge of adrenaline, you sit down at your laptop, you open up one of those AI code generators and you just type in your prompt.
And for a few glorious minutes, it actually works. It does. You get this slick little demo right there on your screen and you feel like an absolute genius. Until you don't. Exactly. Because then you want to actually launch it. You know, you want to add user authentication, design a real logo, set up a custom domain. Host it somewhere secure. Right. And maintain a living database.
And suddenly you just hit this massive brick wall. The whole illusion shatters. You realize you don't just need a clever snippet of code. No, you need an entire software company. And that harsh reality is exactly why we are doing this deep dive today. We've got this really comprehensive stack of product vision documents and technical pitch decks for a platform called App Composer.
It's a fascinating stack of documents, honestly. It really is. And we have a very specific mission for this deep dive. We are going to pitch and sell App Composer to you as if it were our own project and like our very livelihoods depended on you adopting it for your next big idea. I love that framing because it is a fascinating proposition to explore. App Composer is explicitly engineered to be that missing link you just talked about.
The core problem it targets is really the modern creator's trap. Producing the raw software code, that's only a fraction of the actual work. Yeah, getting an idea out into the wild requires so much more. It does. You need design, deployment infrastructure, content management, weedy assets, and a rigorous plan for ongoing operations. Relying solely on a standard chat window to build software is essentially trying to build a house by only ordering bricks.
Yes. You have no mortar. No plumbing. And absolutely no foundation. App Composer is designed to carry a single project through all those really painful handoffs. From the initial spark of an idea all the way to launch. Exactly. Through visual design, the coding, the deployment, and the final public launch, all without losing your original intent along the way.
Okay, let's unpack this because to really understand why this pitch works, we have to trace the pain point back to the origin story of the founder. Right, Dean Loft. Yeah, when you examine his professional background in these source docs, it's an incredibly unique cocktail of experiences. It really is. It's not your typical Silicon Valley resume. Not at all. He spent time in the Royal Australian Navy doing communications, then transitioned into complex systems, networks, and DevOps infrastructure.
But simultaneously, and this is the kicker, he was heavily involved in music production. Right. Working around labels like Shakedown Records and Grind Mode Cipher.
2:58 Music, DevOps and the building-block approach
And that specific intersection, underground music production and high-level DevOps, that's where the architectural philosophy for App Composer was forged. How so? Like, how do those two connect? Well, think about the music industry. Having a finished audio track sitting on your hard drive does not constitute a release. Oh, I see. The track is just the raw material.
Exactly. It's just the core asset. To actually reach a listener's ears and generate revenue, you need album artwork, the digital store page, a promotional website. Social media posts, distribution contracts. All of it. And all those secondary elements are deeply interconnected. You can't simply upload an MP3 and walk away. You need the entire presentation and distribution mechanism functioning seamlessly.
And in his DevOps career, he was dealing with the exact same reality, just translated into software. Spot on. He was constantly managing what happens after a developer finishes writing an app. Right. The permissions, the live deployments, server automation, disaster recovery. All the invisible stuff. His realization was that an independent creator shouldn't have to learn how to operate a sprawling internet company just to publish a useful utility app.
Makes total sense. And from that friction, the sources say Lofts developed this strict three-tier operational philosophy for App Composer. Yeah, it's brilliant in its simplicity. First, reuse what works. Second, pay for specialists when the quality demands it. And third, only build custom code for what is completely missing. That's incredibly pragmatic for solo developers.
It is. I mean, if a component or library already exists and functions perfectly, just reuse it. Do not reinvent the wheel. Right. And if a specific task requires a paid, specialized tool because, say, the enterprise-grade quality justifies the monthly cost, you integrate it. Exactly. But if the capability simply does not exist in the market, that is the only time you should authorize the system to write custom code from scratch.
So App Composer essentially turns that methodology into an automated platform. Yes. It provides reusable building blocks, seamlessly connects to specialist tools via APIs, and utilizes AI agents to write the bespoke code that bridges gaps between them. So to go back to my earlier point, relying on those standard AI code generators is like a factory handing you a beautiful, state-of-the-art car engine.
It's a marvel of engineering, sure. Right, but it's just an engine. You still need wheels and a chassis and registration to actually drive it off the lot. Right. App Composer pitches itself as the entire assembly line. And they don't just hand you the finished car and lock the hood. They hand you the keys to the factory itself. Which brings us to what is arguably their ultimate selling point.
True ownership. True ownership. The platform radically differentiates itself from the closed wall gardens that dominate the current AI landscape.
5:48 Ownership and infrastructure
Yeah, because most AI application builders, they host your project on their proprietary servers, right? Exactly. And if you decide you want to migrate away from their service, you might be able to download a messy zip file of your raw front-end code. But you lose everything else. Everything. You lose the backend database, the hosting environment, user authentication system.
App Composer functions entirely differently. It acts purely as a control plane. Okay, when you say control plane, my mind immediately goes to network architecture. You know, acting as the dispatcher that routes the traffic and coordinates the work rather than the server actually holding the data. Is that what's happening here? That is the perfect analogy. App Composer coordinates all the heavy lifting, but it doesn't trap your application inside its own proprietary runtime environment.
So where does it live? It deploys your project directly to your personal Cloudflare account. Oh, wow. Yeah. Okay. It leverages the modern edge computing ecosystem. It uses Cloudflare Workers to execute your code mere milliseconds away from your users. And what about the data? It uses D1 for your structured SQL databases, R2 for your massive media storage, and durable objects to coordinate live, real-time user sessions.
I find this structure fascinating. If you think about it, workers are like the nervous system, firing off rapid commands at the edge of the network. Yeah, that's a good way to picture it. Well, D1 is the long-term memory storing the structured facts. R2 is the warehouse for the bulky items like user uploads and videos. Exactly. And the durable objects? Well, we'll get into those later, but they are essentially like a designated meeting room, keeping everyone in sync live.
It's really adopting that old server pilot philosophy. Oh, yeah. Server pilot. For anyone who remembers when setting up HTTPS, SSL certificates, and web hosting was an absolute nightmare. Tools like Server Pilot came along and just abstracted all that painful setup away. leaving you to focus purely on your website. Right. App Composer is doing that for autonomous AI agents and Cloudflare infrastructure.
But I am going to push back on this true ownership claim for a second. Okay, let's hear it. I hear the pitch, but let's be real. If App Composer generates a bunch of proprietary, unreadable spaghetti code that relies entirely on hidden internal M-libraries... Right, the vendor lock-in problem. Yeah, having the source code sitting on my GitHub is completely useless if they go out of business.
How are they preventing vendor lock-in at the fundamental code level? Well, if we connect this to the bigger picture, that is the critical vulnerability for most automated code generators. But App Composer sidesteps it by strictly adhering to web standards and standard CloudFlare primitives. So it's not proprietary code? No. The code the AI agents write is standard TypeScript, React, or whatever modern framework you specify.
Okay, that's reassuring. What about the CMS, though? The M-CMS they provide isn't a locked black box either. It is an open architecture designed to manage the content within your D1 databases. So if App Composer's corporate entity just went bankrupt and vanished tomorrow... Your application simply would not notice. Seriously. Seriously. You hold the authoritative readable source code in your own GitHub repository.
The operational infrastructure is running on your separate CloudFlare billing account. And the data lives in my D1 databases. Exactly. You retain total operational independence. You own the factory, the blueprints, and the finished product. Okay, so the architecture keeps my app from disappearing, and it actively avoids vendor lock-in. But true ownership usually implies a massive technical burden.
It does, usually. Right. Like, if I own the factory, doesn't that mean I have to build the whole assembly line myself? How does a non-coder actually initiate this process without getting completely overwhelmed by infrastructure settings? Good question. The process actually starts with a deliberate step they call init. Init, like initialize. Right. You don't just start chatting aimlessly with an AI hoping it guesses what you want.
You are required to provide a structured brief. So no generic prompts. None. You explicitly define the target audience, the specific tasks the application must perform, the desired user experience, and you even provide visual references to establish your specific taste. Oh, that's smart. The system rigidly records all of this context, so your original intent isn't diluted over multiple iterations.
10:09 Get Ready and the first preview
And then from the docs, it looks like before it even attempts to write a single line of code, it executes a phase called Get Ready. Yes, Get Ready, which is just a brilliant piece of engineering discipline. It doesn't blindly assume your setup works and then crash halfway through the build, right? Exactly. It actively verifies your environment. It pings your GitHub to assure repository access.
It authenticates your Cloudflare credentials. It tests your chosen AI agent, API keys. So it definitively proves the foundation is solid before it attempts to build the house. That verification prevents the cascading failures that plague so many AI development tools. Okay, so the foundation is verified. The agent builds a functional preview of your app. Then what?
Well, once you have that preview, you interact with the interface in a fundamentally different way. How so? Think about a standard setup. If the AI makes a visual mistake, you have to go back to the chat box and try to articulate the problem textually. Yes. You type something like, the submit button on the top left of the user profile card is too big. Exactly.
And often the AI misinterprets the text, decides to rewrite the entire page architecture, and breaks your navigation bar in the process. I have lived that specific nightmare more times than I can count. You ask for a font change and suddenly your database connection drops. It's maddening. App Composer eliminates that entirely by introducing a visual workbench.
A visual workbench? Mm-hmm. So how does that work? You look at the actual rendered preview of your app, and you interact directly with the document object model or the DOM. So I'm clicking on the actual app, not typing in a chat. Exactly. You point your cursor directly at an element on the screen, select the specific card, and tell the system, make this card smaller on mobile screens.
Oh, wow. The system retains the exact hierarchical context of that specific element. It surgically targets the CSS or the component logic for that one card without casually overwriting all the functioning code surrounding it. That is huge. It's like having a seasoned project manager, a graphic designer, and a senior developer all looking at the exact same physical whiteboard.
That's a great way to look at it. You are pointing right at the issue with your finger rather than playing a terrible game of corporate telephone through a text prompt. And the platform's polish doesn't stop at the raw code. They have an entire integrated suite dedicated to the final presentation. Presentation is treated as a first-class citizen here, which is really rare for developer tools.
Very rare. The suite includes Brand Studio, which systemizes and preserves your visual identity, ensuring your typography, color palettes, and brand voice remain consistent across the entire application. Nice. Then you have Media Studio, which provides tools for the creation and manipulation of artwork, audio, and video assets directly within the workflow. And finally, you have LaunchKit, which honestly, LaunchKit is the unsung hero here.
It really is. Because what good is a perfectly functioning app if the link looks like an absolute scam when you text it to a friend? Nobody's going to click that. Exactly. LaunchKit automatically packages your app icons for different devices, generates your progressive web app manifests, and creates those perfectly cropped open graph social media sharing images.
It handles all the tedious marketing plumbing. So we have discussed the theoretical workflow and the architecture, but to truly validate this pitch, we need to look at what they've actually built. Because talk is incredibly cheap in the tech industry. Very cheap. So App Composer uses its portfolio of operational applications to prove its agents can handle rigorous real-world workloads.
13:42 Utilities and games from the portfolio
Right. And they categorize some of these as utility mini-apps. Which serve a dual purpose, right? Right. They are standalone products, but they're also reusable building blocks for much larger applications. Exactly. Take paperwork, for example. It is a browser local PDF filler. And the key feature there is privacy. You can fill out fields, draw signatures, and modify local files without your sensitive documents ever being uploaded to a remote server.
The entire process utilizes browser APIs to keep the data strictly on your machine. Brilliant. Then there's LDraw, which is an editable diagramming workspace built on top of the Excalibraw engine. The technical achievement with LDraw is how the platform handles state. What do you mean by state in this context? Both human users and autonomous AI agents can edit the exact same native scene.
Typically, when an AI generates a diagram, it just exports a flattened PNG image. Right. And if you need to change one word in a box, you have to regenerate the entire image and pray the AI draws it exactly the same way. Which it rarely does. But in LDraw, the AI manipulates the native vector objects. Oh, that's wild. Yeah. If the AI drafts a complex flowchart, A human can simply click on a specific box and drag it across the screen.
The elements remain distinct, editable objects. That's a massive workflow improvement. They also feature applications like Linkarooie and HereThere, right? Yes. Linkarooie operates as a personalized profile page, and HereThere is a moderated digital guestbook where visitors can submit photographs. And the interaction between those two apps is what proves the platform's maturity regarding data security, according to the docs.
Exactly. The Linkarooi profile page can automatically pull approved photos from the here-there guestbook. But they don't just mash the databases together. No, they share data through a strictly defined API contract, maintaining entirely separate ownership and moderation states. So the guestbook retains ultimate authority over the original photos and the moderation decisions.
Right. If an administrator revokes a photo's approval in the guestbook, it instantly and automatically disappears from the profile page. It proves the platform intrinsically understands secure data boundaries between separate microapplications. It really does. But while the utility apps demonstrate security and privacy, if we really want to stress test this system's capabilities...
We have to talk about the games. We must look at the games. Games are notoriously demanding. The portfolio includes Loftwah Fighter, which is a local first real-time squad battler. And that requires precise charge timing and combo move execution. They also built SHOALSHOT, a tide pool target game where players must track moving shoals of fish and play shots with touchscreen precision.
And most notably, they developed Protocol 11. Protocol 11. Yes. It's a multiplayer card game that relies on those Cloudflare durable objects we mentioned earlier. Right, to manage live online rooms and reconnectable user sessions. But wait, why are games the ultimate benchmark here? I mean, why wouldn't they showcase like a complex enterprise accounting software to prove their worth?
What's fascinating here is that a conventional business application, say a form that submits text to a database, that can hide a multitude of architectural flaws. True. If a submit button takes an extra half second to load, no one really cares. Or if a database query is slightly inefficient, the end user rarely notices. But games. Games expose performance defects instantly.
Oh, absolutely. If the frame rate stutters during a combo move in Loftwah Fighter, it's over. Or if the touchscreen input latency is clumsy on a mobile phone and it's SHOALSHOT, the game is fundamentally unplayable. It fails the user test instantly. And Protocol 11 takes that stress test to the network level. A multiplayer card game requires a continuous synchronized state between multiple players.
Right. If someone's connection drops on a mobile network, the game can't just crash for everyone else. And that's where those Cloudflare durable objects come in. Yes. The durable object acts as a single, persistent point of truth on the edge network. It holds the current state of the card table. So if a player reconnects, the durable object simply updates them on what they missed.
Exactly. If App Composer's autonomous agents can successfully architect, deploy, and manage the real-time state of a complex, multiplayer game like Protocol 11... Then it can absolutely handle the performance, latency, and timing requirements of your local small business website. Without breaking a sweat. Okay. I am completely tracking with the performance capabilities, but, and this is a big but, this raises a massive red flag for me.
18:25 Keeping agent permissions bounded
Let's hear it. If we have AI agents powerful enough to autonomously architect real-time multiplayer games, and those agents are hooked directly into our live Cloudflare databases. And where are you going with this? How do we keep the AI from hallucinating on a random Tuesday and accidentally dropping the entire production database? AI needs a leash, a very short, very strong leash.
It's a valid concern. And the platform addresses this through strictly enforced agent boundaries and role-based access control. Okay, how does that work in practice? The system's architecture deeply understands the critical differences between permission to read data, permission to edit a draft, permission to deploy code to a staging environment, and permission to publish directly to production.
So it's very granular. Very. For instance, you might grant an AI agent a tightly scoped permission to draft a change to a promotional video within Media Studio. Okay. The agent can edit the timeline, apply filters, and suggest a new cut. But it physically cannot publish that video to your live social media channels without an explicit cryptographic authorization from the human owner.
Here's where it gets really interesting. I think of the AI as a brilliant, incredibly fast, but overly eager intern. That is the perfect analogy. You give that intern a very specific, limited-access keycard that only opens the door to the design room. You absolutely do not give them the master key to the subterranean vault where your production user data is stored.
Exactly. And that boundary enforcement applies to your custom code tweaks as well. What do you mean? Well, let's say you manually access the code base and write some custom CSS to make a drop shadow look exactly the way you want it. Okay. If you later ask the AI agent to add a new navigation button to that exact same page, App Composer's architecture ensures the agent operates strictly within the bounded context of the new button component.
Oh, so it can't touch the rest of the page. Right. It is structurally prevented from casually overriding the global style sheet and destroying the custom CSS you labored over yesterday. That is a massive relief. Okay, so the underlying tech is robust. The workflow actively prevents the typical AI hallucinations. And the gaming portfolio proves it can handle latency.
It checks a lot of boxes. It does. But for our final pitch to you, the listener, we have to talk about your wallet and your standards of quality. Always comes down to the money, right? Always. How much does the sprawling infrastructure cost to run on a daily basis? And how do we objectively measure if an app composer project is actually a success? The economic philosophy baked into the platform is vital for long-term viability.
App Composer explicitly utilizes the smallest appropriate AI model for any given task. Okay, so it's not just spamming GPT-4 for everything. Definitely not. You do not need to call a massive, computationally expensive frontier language model just a crop of social media image or validate a zip code in a form field. Right, or package an app icon. The platform utilizes compact, deterministic tools and smaller, highly efficient models for those routine data transformations.
Which is a huge relief. Because if every single time a user clicks a button on your app, it triggers an API call to a massive model that costs you five cents in compute fees. Your app will literally bankrupt you the moment it goes viral on social media. You would be punished for your own success. Precisely. The system only invokes the heavy, expensive reasoning models for ambiguous project planning, complex cogeneration, or nuanced creative judgment.
And this strict economic discipline is what makes running the finished application genuinely affordable long-term on Cloudflare's serverless infrastructure.
22:12 How to judge the finished work
Right. But affordable doesn't mean anything if the output is garbage. Exactly. And to make sure you actually get what you pay for from these agents, They have instituted this brutal, uncompromising gauntlet that every single project has to pass to be considered a success. The six-gate benchmark. Yeah. Gate one. It has to be a useful application that actually completes the requested task.
Seems basic, but essential. Right. Gate two, finished presentation. Yeah, the presentation gate is critical. The user interface, the written copy, and the visual media all have to work together cohesively. It cannot look like a disjointed wireframe. Right, because we've all seen those ugly AI apps that technically function but look like they were built in 1995.
Oh, absolutely. Gate 3, an accurate launch package. The marketing materials generated must perfectly match the actual reality and feature set of the app. Gate 4, real distribution. It has to successfully publish to the authorized channels without throwing deployment errors. Gate 5, continued operation. The app must survive routine maintenance and subsequent feature additions without the whole architecture collapsing.
And the final gate, gate six. Proud to share. Yeah. The human owner must accept the final result and be willing to put their name on it. But you know, the most important aspect of this benchmark is how they track failures through what they call intervention accounting. Okay, wait, let me make sure I understand how strict this is. If I use this platform, the AI builds the entire app, but there's a tiny typo in the database schema.
Okay. It takes me five minutes to open the code, manually fix the typo, and deploy it. Does that count as a failure for the platform? Yes, that is a total failure. Wow. The platform's benchmark defines any human debugging, manual code editing, or tasks chasing as an intervention. If you have to step in and fix the code to make it function as requested, the platform failed the autonomous test.
That's intense. The tech industry is notorious for hiding behind flashy, heavily edited video demos that were secretly repaired by a team of human engineers behind the scenes. We see it all the time. App Composer's intervention accounting forces radical honesty. It only claims a project is a success if the AI agent delivered the result completely autonomously through all six gates.
That is an incredibly high bar for any software company, let alone an AI platform. It really is. So to bring this entire pitch home, think about what you want to build right now. Your big idea. Yeah. Maybe it's a bespoke internal tool to impress your boss at the next corporate meeting. Maybe it's a community hub for your neighborhood, or maybe it's that indie game you've been sketching out in notebooks for years.
App Composer is pitching itself as the only ecosystem that respects your time by not making you repeat your prompts. It preserves your personal taste through its integrated design studios. And most importantly, it hands you the actual keys to the castle. The native source code and the independent infrastructure right at the very end of the process. It is a highly compelling promise for the modern creator.
pairing the raw speed of AI generation with the rigorous discipline of traditional software engineering. All while guaranteeing true operational independence. It really is the holy grail if they can consistently deliver on it. If they can, yeah. And before we wrap up, I want to leave you with a final thought to Molliver. Ooh, okay. Because buried deep in the technical source documents is a brief mention of a specialized pathway for migrating aging WordPress sites into the App Composer ecosystem using their EmDash CMS.
Oh, wow. Consider this. There are hundreds of millions of clunky, outdated WordPress sites currently holding the internet together with digital duct tape and vulnerable plugins. A lot of duct tape. What happens to the entire web ecosystem when an autonomous AI agent can not only read those old sites, but autonomously consume their data, upgrade them into blazing-fast edge-deployed app composer projects running on Cloudflare, and hand the keys back to the owner.
That is, I mean, the implications of that capability are staggering. Is this the beginning of a massive, automated internet renovation? If the technical and financial barrier to modernizing legacy infrastructure drops to near zero, the entire landscape of the internet could shift dramatically in a matter of years. From hitting a brick wall with a simple shower idea to potentially renovating the fundamental fabric of the internet.
What a jump. Thank you so much for joining us on this deep dive into the App Composer pitch decks. Keep exploring, stay curious, and maybe it's finally time to take that brilliant idea out of the shower and launch it into the real world.
Replacing WordPress with App Composer
A two-sided debate about plugin permissions, backups, migrations and the trade-offs of a federated stack. 14 min 57 sec
Read the full transcript
Automatic transcription with product names corrected.
0:00 One roof or connected services?
Welcome to the debate. You know, when you buy an old historic house, there is this undeniable charm to it. You love the fact that everything is under one roof, the way the rooms naturally flow into one another. Oh, for sure. Right? It's character. Right. It feels incredibly cohesive, like a single unified entity. Yeah, it's comfortable. Exactly. Well, until you try to upgrade the plumbing in the kitchen. And you suddenly realize that moving one pipe somehow breaks the heating system in the upstairs better.
Right. Because the systems are fundamentally structurally entangled. And that is the exact moment you realize you don't just own a house, you own a highly fragile ecosystem where every wall you open holds a new potentially disastrous surprise. And that surprise usually happens on a Friday afternoon when you have a business to run. Always. Friday at 4 p.m., right?
And, I mean, for well over two decades, that is exactly how we have built and maintained things on the web. We've all been living in that historic house, and it's called WordPress. We have. But today, we are looking at a radical blueprint for the future of the web. It's a recently published vision for a platform called App Composer. And it proposes tearing down that monolithic house and replacing it with a completely decentralized federated architecture using tools like M-CMS and Cloudflare.
Which is a massive paradigm shift. Right. And it really forces us to ask a central question today. Why would an organization actually choose to endure the pain of migrating to App Composer, EmDash, and Cloudflare over just maintaining their traditional WordPress site? Right. Does this new federated architecture actually solve WordPress's structural flaws, or does it just introduce a mountain of unnecessary complexity for website owners?
Yeah, it's a huge question. To ground this, we're looking directly at the App Composer, the Completed Product Vision document. This is dated November 20, 2026. And we're specifically focusing on the chapter regarding the WordPress migration path and what they call the EmDash opportunity. Right. So my position is basically this. I argue that App Composer and EmDash represent a necessary secure evolution in web architecture through federated services and sandbox plugins.
And my stance is that the cognitive load of a federated system, plus the loss of WordPress's mature, deeply integrated plugin ecosystem, makes the App Composer stack an impractical choice for many business owners. Okay, so to really understand why this shift is even being proposed, I think we have to look honestly at how traditional WordPress is structurally compromised.
Compromise is a strong word. Well, it was built in an era where an application was just a bunch of PHP files sitting on top of a single MySQL database, all in a single server. It's entirely monolithic. Which is how most of the web still works. True, but it's an unisolated execution model. App Composer flips that. It doesn't try to be the database, the server, and the file system all at once.
It acts as what they call a control plane. Right. It connects explicit, specialized services. So you have GitHub acting as the authoritative source for your code. You have EmDash, which is built on Astro, a lightning-fast web framework, handling the content workflows. And then you have Cloudflare D1 managing structured records, and Cloudflare R2 handling all the heavy media storage.
It's modular, it's clean, and specifically it uses a sandbox plugin format for EmDash that enforces declared capability boundaries. WordPress plugins completely fail to do that, which just leads to security and operational bloat. Well, I come at it from a very different angle. That monolithic nature of WordPress, the very thing you are calling a structural compromise, that is exactly why it remains so incredibly successful for actual business functions.
I mean, it's successful, but at what cost? At the cost of simplicity. You are calling Composer a control plane, but what I see is severe fragmentation. Look at the source material itself. The architects admit that migration requires translating custom shortcodes, complex page builders, and intricate commerce workflows into MDux's completely different model. Right. It's a translation process.
A translation process that they admit often lacks functional parity. For a business owner who literally states they do not want to maintain underlying machinery, this is a nightmare. Managing the relationships within Cloudflare Workers, message queues, R2 object storage, and D1 databases, that is vastly more complex than a single WordPress instance. Okay, I want to push back on that because I look at that exact same distributed architecture and I see a massive security and stability upgrade, especially when we talk about plugins.
4:19 The plugin dilemma
The lifeblood of WordPress. Exactly. The plugin dilemma. Let's get into it because this is the most tangible difference for real users. In WordPress, every single native plugin shares the exact same execution boundary. Meaning they all run in the same memory space. Right. So if I install a simple, seemingly harmless calendar plugin in WordPress, under the hood, the PHP engine is loading that plugin with the exact same permissions as the core user authentication system.
Sure. A single badly coded or maliciously compromised calendar plugin can bring down the entire site. It can read all the user passwords, rewrite core files, it compromises the whole site. EmDash shifts entirely away from this by using strictly sandbox plugins and Cloudflare's managed execution. But, and this is a big but, that shared boundary in WordPress is precisely what allows for the deep, seamless integrations that users rely on.
See, I'd argue that deep integration is a bug disguised as a feature. Let me give you an analogy here. If WordPress is a house where every guest gets a master key to every single room, Okay. then EmDash is a modern hotel where key cards are strictly scoped to declared capability boundaries. A guest can open their specific room, right? But they mathematically cannot wander into the security office or the hotel kitchen.
That sounds great in theory. It works in practice. If an EmDash plugin needs to format a date on the front end, it doesn't also secretly gain the ability to read the backend database. I hear you, but I just don't buy that the strict sandboxing doesn't completely cripple the platform. That strict isolation inherently limits the deep integrations that make WordPress powerful.
How so? Think about something like WooCommerce. It doesn't just slap a shopping cart on a page. It embeds itself so deeply into the WordPress core that it transforms a simple blog into a massive e-commerce engine. It modifies user roles, intercepts the mail system, alters URL routing. You absolutely cannot do that in a strict sandbox. Because doing that makes the system incredibly fragile.
Fragile maybe, but highly functional. And the Composer Vision document explicitly admits this. it notes that if you have a, quote, complex commerce workflow, you might need to just retain your external checkout only. Why? Because EmDash cannot easily replicate that deep functional parity natively. Well, yes, it forces you to use dedicated commerce tools instead of hacking a blog to do it. But you are sacrificing the very utility that makes the web platform useful for small businesses just to achieve some theoretical architectural purity. It is not just theoretical purity, though, it is about explicit service boundaries and what it actually means to operate a platform reliably, which leads directly to this broader concept in the document, the idea of federated ownership. Ah, yes, federated ownership. Right. Under App Composer, connected systems retain authority over the work they are best at managing. EmDash handles the content lifecycle. Cloudflare reports the infrastructure state. GitHub tracks the code history. It creates crystal clear boundaries of responsibility. But this so-called federated ownership is exactly what creates an operational
7:22 Backups and operational ownership
headache for the average user. Really? I think it clarifies things. Let's look at what ownership actually means to a normal, non-developer person. In the WordPress world, ownership is delightfully simple. You have a database dump file and a zip file of your wp content folder. That's it. You hold those two files and you have your entire digital business in your hands. Sure, it's two files. Right, but App Composer splits your project across GitHub for source, D1 for SQLite records, R2 for object storage, Media Studio. It scatters your business. If a deployment fails, recovery means you have to wrangle code, configuration, structured records, and objects separately.
But they are purpose-built tools. They are, but a WordPress backup is often a single cohesive snapshot. If something breaks on Thursday, you click restore, and the whole thing rolls back to Tuesday at 2 p.m. Federated ownership turns a simple restore into an engineering investigation. Okay, wait, I have to ask you, isn't the simplicity of a monolithic WordPress backup actually a really dangerous illusion?
How is it dangerous? It saves businesses every single day. Because of what you destroy when you use it. Think about your exact scenario. You roll back the entire monolithic site to Tuesday at 2 p.m. to fix a broken code update you pushed on Thursday morning. What happens to all the user content generated since that snapshot? Well, yeah, you lose the Wednesday data.
Exactly. Rolling back code inherently means losing all user content, comments, orders, editorial drafts generated since that snapshot. In Composer, separating these life cycles prevents catastrophic data loss during rollbacks. Okay, fair. A code rollback in Composer just restores the GitHub code version. It does not automatically revert your D1 database changes, and it doesn't delete the media your team uploaded to R2 yesterday.
That is a very compelling point about data loss, but have you considered the cognitive load required to actually build and maintain that separation?
9:18 The cost of coordinating services
The framework handles a lot of it. Does it? Let's look at how these federated systems communicate. The Composer document talks about Cloudflare queues providing at least once delivery. Right. Which means a task won't just get dropped if the server restarts. But at least once doesn't mean exactly once. It means your applications require item potency, which is a fancy way of saying you have to manually handle duplicate requests.
Well, yeah. If a queue sends a command to process a heavy video and there's a network hiccup, it might retry and send it again. Now you have two identical commands. In a monolithic system, the relational database transaction just rolls that back cleanly. But here, the developer has to engineer the app to constantly check, wait, did I already process this? Did I already charge this card?
You are shifting a massive burden of data consistency right onto the website owner. I see what you're saying. But you're assuming the developer is just building this from scratch with raw cues. App Composer provides typed composition. The explicit contracts manage those boundaries. And frankly, this strict, explicit separation of logic and data is exactly why Composer is uniquely designed for AI agents.
Oh, I knew we'd get to the AI integration eventually. We have to. It's a huge part of the vision document. We are moving into a world where AI agents aren't just writing chat snippets. They will execute routine workflows in production. Because capabilities are strictly typed and EmDash uses a scoped MCP server, that's model context protocol, agents can safely interact with the system.
But giving an autonomous AI agent access to a live, complex business site is inherently risky. Not if the architecture enforces strict boundaries. Think about WordPress. If you give an AI assistant plugin access to draft posts, it implicitly gains access to the shared execution environment. It could theoretically rewrite the database. Due to the shared memory space.
Yes. But with EmDash and MCP, an agent can be given permission to draft content without secretly gaining permission to publish it or spend API credits or rewrite the database. The contracts are mathematically enforced. Okay, let's talk about the practicality of those AI agents then. The document introduces this idea-to-operation benchmark, right? Yes. It's meant to prove an AI can take a brief and deploy a working app.
But the benchmark requires zero manual intervention. Zero. Yet we both know that migrating from a legacy WordPress site almost always requires heavy human judgment.
11:39 What a migration really involves
Well, migrating is different than generating a new app. But that's exactly the problem. Transforming a tangled WordPress site with legacy URLs, custom fields, and private content behavior into EmDash's astro-based model? AI cannot safely untangle that without significant, costly human oversight. It's essentially a total rebuild, not a migration. It is a rebuild of the front end, yes, but Composer doesn't leave you stranded.
The vision details the migration map. It specifically handles the scary stuff, reconciling URLs locally and producing verified Cloudflare redirects before anything goes live. But the source text literally states, quote, a successful import alone does not establish full functional parity. You still have to manually rebuild complex behaviors. For many business owners, that friction is economically unviable.
They don't want to rebuild. They just want their site to work. I get that it's friction. But this controlled cutover provides a cleaner, faster, and infinitely more scalable site on Cloudflare Workers. You are freeing the owner from perpetual, stressful server patching. No more waking up wondering if a slider plugin just got your database hacked. You're just trading the stress of server patching for the stress of managing distributed cloud relationships.
If you don't want to maintain machinery, managing workers, D1, R2, and Qs is a lot of machinery. But you don't manage the physical servers. That's the point of serverless edge computing. And the open source core of Composer means you truly own it. You can detach Composer and just run your code on your own Cloudflare account. Which still ties you deeply to Cloudflare's specific proprietary infrastructure.
It ties you to edge computing, yes, but the code in GitHub is yours. The D1 SQLite database can be exported as a simple file. It is true ownership. I just think for an owner who, quote, does not want to maintain underlying machinery,
13:20 Who should consider switching?
WordPress shared hosting is still far simpler. Well, we are coming up on time, so let's summarize where we both stand on this. Sure. I'll reiterate that App Composer and EmDash provide a totally necessary architectural leap. They offer true federated ownership, sandbox security that prevents those cascading plugin failures, and explicit AI contracts on Cloudflare that prepare sites for the next decade of the web.
And I will reiterate that the unified utility of WordPress is incredibly hard to beat. The federated complexity of the Composer stack, managing multiple distinct cloud services, may severely alienate owners who simply want their business functions to work without having to rebuild their entire functional parity from scratch. I think, though, we can both acknowledge a point of convergence here.
We both agree on the importance of separating infrastructure management from content creation. Oh, absolutely. And I'll concede that for brand new projects, you know, Greenfield apps without legacy WordPress baggage, the Composer stack offers a really pristine, impressive starting point. Yeah, it's a fascinating architecture. And for our listeners, I highly suggest reflecting on the value of looking closely at how your current web platforms manage capability boundaries.
Definitely. You should explore the source materials decision explorer and the EmDash porting guides, just to see how your specific plugins would fare in a system like this. It's an eye-opening exercise for sure. It really is. So, do you stick with the charming but entangled historic house? Or do you move to the highly secure, strictly zoned modern hotel? That is the architectural choice we all have to make.
Thanks for joining us on The Debate.
Read the slide deck

App Composer Overview
15 illustrated slides on ownership, the creator’s workflow and the systems behind it.
Read the slide-by-slide guide
App Composer
Turn an idea into an owned project. Source code, data, infrastructure and agent actions each have an owner.
The work around the code
The slides illustrate how work gets lost between chat, code, design, hosting and later changes. The 20% figure is illustrative.
What ownership means
The deck compares tools on source ownership, maintenance, portability, media integration and data sharing. These are questions to ask about a tool, since capabilities vary.
The return visit
Shape the brief, build, polish, ship, then reopen the same project to make a real change.
The Cloudflare foundation
Workers run applications and APIs. Workers AI handles selected inference. D1 stores structured records and R2 stores objects.
Operating after launch
GitHub holds source and history. EmDash provides an editorial workspace for updates and records within its scope.
The creative pipeline
Keep the brief, working media, versions and approved exports together as a project moves through Media Studio.
Agent permissions
Inspection, edits, execution and publication carry separate authority. The owner can inspect the work before granting a consequential action.
Choose the right compute
Use deterministic software for tasks such as a crop or calculation. Use models where a task benefits from interpretation or creative judgment.
Utilities and connected apps
Paperwork, Launch Kit, and the Here / there and Linkarooie pairing illustrate local editing, portable branding and sharing across independently owned apps.
Games and interactive state
Protocol 11, LOFTWAH FIGHTER and Foilbury illustrate different needs around multiplayer state, simulation and collectible records.
How the systems fit
Composer connects GitHub, Cloudflare, EmDash and Media Studio. Each connected system keeps responsibility for its part.
The cost of an accepted outcome
Benchmarks should include corrections, debugging and deployment effort. The chart’s percentage is an illustration.
Paths for different teams
The vision describes a guided path for creators, repeatable client deployments for teams and source-level controls for engineers.
The finish standard
The project should do its job, look finished, match its public claims, reach the intended destination and survive a later change.