Claude Code + Fling = Ship Real Apps in One Loop

Añadido: 2026-05-17

[00:00:00]Most people using Cloud Code can build something useful in a few minutes, but the second you want to actually put it on the internet, that's where things slow down. You're suddenly dealing with hosting, setting up a back end, wiring a database, and figuring out how all these pieces connect, which honestly has nothing to do with the app you were trying to build. That's basically the gap Fling is trying to fill. Instead of treating deployment as this separate step, it plugs directly into Cloud Code, so your project already knows how to go live. You build something, you tell it to deploy, and it handles the front end, back end, database, and even things like bots in one flow. So, in this video, we're not just going to talk about it, we're actually going to build something [music] end to end and ship it. The app we're making is a simple ask me anything page that you can drop into your YouTube description or social bios where people can submit questions and you can answer the best ones on a public feed. The interesting part is how we handle moderation. Instead of building some custom dashboard, every question gets sent straight into a private Discord channel. You read it there like a normal message, and when you reply, that answer automatically updates the website. So, your Discord basically becomes your admin panel without you having to build one. And the goal here is to keep everything inside one workflow. [music] We're going to start from nothing, use Cloud Code to build the entire app with Fling, and then deploy it so it's live on a real URL. No manual setup, no jumping between services, just one continuous loop from idea to something you can actually share. Before we jump into the terminal, I want to quickly map out what this app actually looks like under the hood because this is where things usually get messy if you're building it the traditional way. At the front, we have a simple React page. This is the part your viewers see. It's basically just a clean page with an input box that says ask a question, and below that, there's a feed of questions you've already answered. Nothing complicated here, just a form and a list, but it still needs to talk to a back end somewhere. Behind that, we've got a back end API handling the submissions. So, when someone sends a question, the front end calls an end point, and that end point is responsible for storing the question and triggering everything else that needs to happen.

[00:02:01]Normally, this is where you'd be setting up a server or serverless functions manually, but with Fling, this is already scaffolded for you. Then we have the database. This is just a simple table storing each question, the answer, a status like pending or published, and a timestamp. In a normal setup, you'd go create this in something like Superbase or Firebase, deal with API keys, and wire it into your back end. Here, we're just going to tell Cloud Code to use the built-in database and it already knows how to read and write to it. Now, the most important piece is the Discord bot because this replaces an entire admin dashboard. Every time a new question comes in, the back end sends it to a private Discord channel. You'll see it as a message from the bot, and from there, you can just read it like any other message. When you want to answer, you just reply directly to that message.

[00:02:44]That reply gets picked up by the bot, sent back to the back end, saved into the database, and then the front end updates to show the question and your answer publicly. So, instead of logging into some dashboard, you're just using Discord like you normally would. So, the full flow looks like this. User submits a question on the site, back end stores it and sends it to Discord, you reply in Discord, that reply updates the database, and then the website reflects the answer. And the reason this is a good example is because it touches everything. You've got a front end, a back end, a database, and a bot all working together. Normally, that's a lot of setup across multiple services, but we're going to build all of this just by talking to Cloud Code and letting Fling handle the infrastructure in the background. All right, I want to quickly show what Fling is doing differently because otherwise the workflow we're about to do won't really make sense.

[00:03:33]Normally, when you build something with Cloud Code, you're just generating code locally. You might get a front end, maybe some back end routes, but it still lives on your machine. If you want to turn that into a real app, you have to go figure out hosting, databases, storage, and all that separately. What Fling does is bundle all of that into one environment. So, instead of thinking I need React here, a back end there, a database somewhere else, it just treats your app as one unit. When Cloud writes the code, Fling already knows how to run it, store data, and expose it on a public URL. So, for example, in our case, when we ask Cloud to build this AMA app, it's not just generating a page, it's also creating the API to handle submissions, setting up a database to store questions, and wiring up the Discord bot logic. And the important part is all of that is already connected. You're not passing API keys around or configuring services manually.

[00:04:23]Another big thing is deployment.

[00:04:25]Normally, even after everything works locally, you still have to push it somewhere like a hosting provider and hope everything is configured correctly.

[00:04:32]Here, deployment is basically one command. You run flingit push, and it packages everything and puts it live on a dotflingit.run domain. So, instead of thinking in terms of separate services, the mental model here is more like you're just describing an app, and Cloud builds it inside an environment that already knows how to run and deploy it.

[00:04:50]That's why this works really well for smaller tools like the one we're building. You don't have to spend time on setup, you can just stay focused on what the app should do and keep iterating until it works the way you want. So, let's actually get this running. First thing you want to do is head over to flingit.io and grab the CLI for Fling. Once you're there, copy the NPX skill ones and then paste it into your terminal. You can install it globally if you want, but using NPX is honestly quicker if you're just trying it out. Okay, now you want to pick Cloud Code and then press enter. After that, it'll initialize a workspace for you. At this point, nothing fancy is happening yet. It's just setting up the environment so everything is ready to go. Now, here's where we switch over to Cloud Code because instead of manually building the project, we're going to let it scaffold everything using Fling's skill. Inside Cloud Code, paste this: Make me a Fling project here. What this does is load Fling's skill into Cloud, so it understands how a Fling project should be structured. Instead of guessing how to wire things up, it now has a template for front end, back end, database usage, and integrations. Give it a bit of time and you'll see it start generating files. Usually, it creates a React front end, a back end using Hono, and some basic routes and config to tie everything together. You don't need to touch anything here yet. Just let it finish. Once that's done, you'll have a working base project, but it's still generic. So, now we're going to turn this into our actual AMA app. Go back into Cloud Code and give it a more specific prompt, something like extend this Fling project into an AMA app. I want a public page where users can submit questions, store them in a database, and send each question to a private Discord channel. When I reply in Discord, that answer should be saved and shown on the website. The important thing here is you're describing the behavior, not the implementation. You're not telling it how to build the API or how to connect the database. You're just telling it what the app should do. At this point, Cloud will start generating multiple parts of the app at once.

[00:06:38]You'll see it creating front end components, back end routes, and even starting to wire up the Discord bot logic. This is where things would normally split into separate services, but here, it's all happening inside one project. Let it run through the first version, and once it's done, we'll go through each part and make sure everything lines up with what we actually want before we deploy it. Once Cloud Code finishes generating the app, don't just assume it's perfect and deploy it right away. This is where you want to spend a bit of time checking each piece because this is also where you understand what it actually built.

[00:07:08]Start with the front end. Open up the React app and see what it gave you.

[00:07:11]Here, I got a basic page with an input and a list of four what seems like answered questions, but it's empty now.

[00:07:17]The site looks a bit bland right now, so let's ask Cloud to update it. For example, update the UI style to be more stylish yet minimalistic. It'll rewrite the component, and you'll see the changes instantly. You don't need to worry about styling frameworks or configs here because Fling already handles how this gets served. Now, move to the back end. You should see some API routes already created, usually a post end point for submissions. This is where the form sends data when someone asks a question. What we want to confirm is that when a question comes in, it actually gets saved properly. So, if it's not clear, just ask Cloud: Make sure the submission end point stores the question with a status of pending and includes a timestamp. This keeps things structured for later when we publish answers. Next is the database. This is one of those areas where normally you'd be jumping into another service, but here, it's already part of the environment. You just need to make sure the structure makes sense. We want something simple, a question ID, the question text, an answer field, a status field like pending or published, and a timestamp. If Cloud didn't define it clearly, just tell it to create or adjust the schema. It'll handle the underlying setup without you touching any configs or keys. Now, the important part, the Discord integration. This is where the app becomes actually useful.

[00:08:29]Discord is already in place, but we also need the reply flow. So, tell Cloud: When I reply to the bot's message in Discord, take that reply, update the corresponding question in the database, and mark it as published. This is what turns Discord into your admin panel.

[00:08:44]Once everything looks good locally, this is the part where things usually get annoying, but here, it's honestly the simplest step. Instead of figuring out hosting or setting up separate services, we're just going to deploy directly through Fling. Go back to Cloud and ask it to deploy it with Fling. What's happening here is it takes your entire project, front end, back end, database setup, bot logic, and bundles it into something that can run on Fling's infrastructure. You'll see some logs as it goes through packaging and deploying, and after a few seconds, it'll give you a live URL. Open that link, and now your app is actually on the internet. No extra setup, no environment variables to configure manually, it just works out of the box. Now, before we even test everything, this is already the part that's different. Normally, you'd still be in the middle of setting up hosting or debugging deployment issues. Here, we're already at a live app, and we can start interacting with it right away.

[00:09:34]So, what we're going to do next is run through the full flow end to end. Start on your live site. You should see the input box and the feed section below it.

[00:09:41]Right now, the feed is probably empty, so let's submit a few test questions.

[00:09:45]Type something simple like what stack do you use and hit submit. Then maybe add one or two more just so we have multiple entries to work with. Now, switch over to Discord. In your private channel, you should see those questions come in as messages from the bot. If they show up instantly, that means your front end, back end, and bot integration are all connected properly. From here, just treat it like a normal workflow. Pick one of the questions and reply with {slash} answer, and then just whatever your reply is. Once you send that, go back to your website and refresh. You should now see that question appear in the feed with your answer attached to it. That means the reply got picked up, the database was updated, and the front end is now pulling the correct data.

[00:10:23]Now, try a couple more scenarios. Reply to another question, leave one unanswered, and refresh again. You should see that only the answered ones show up publicly, while the unanswered ones stay hidden. This is important because it means your filtering logic is working. If something doesn't work perfectly, this is where you go back to Claude Code and fix it in place. For example, if replies aren't linking correctly, just tell it to match Discord replies to the correct question ID, let it update the code, and then run flingit push again. What's nice here is that iteration loop. You're not redeploying across multiple services, you're just updating the project and pushing it again, and the live app updates in seconds. Now that everything works, this is usually where real usage starts because the first version is almost never exactly how you want it. Let's say you want to tweak the UI a bit. Maybe the page looks too plain, or you want to add something like a title, a profile section, or even just clean up spacing.

[00:11:18]Instead of opening files and manually editing everything, you can just go back to Claude Code and describe the change.

[00:11:24]For example, you can say, "Add a header with my name and a short description at the top of the page, and make the layout more centered and clean." Claude will update the front end code, and once it's done, you can check the changes first through the local dev server, and review the changes. While we're here, let's add a new feature as well. Let's say you want to add something like uploading questions or limiting spam submissions.

[00:11:45]You don't need to redesign the whole system, you just describe the behavior.

[00:11:49]Something like, "Add a rate limit so users can only submit once every 30 seconds, and allow users to upvote questions and sort by most popular."

[00:11:57]Claude will update the back end and database logic accordingly, and again, you just redeploy with one command. The main thing here is that you stay in one loop. You're not jumping between a hosting dashboard, a database panel, and a bot server. Everything lives inside the same project, and Fling handles the infrastructure in the background. So, instead of thinking in terms of setup, deploy, maintain, it's more like build, test, tweak, push over and over again until the app feels right. Okay, now that we've built it, deployed it, and even tweaked it a bit, this is where it's worth stepping back and looking at what would normally happen if you tried to build this without Fling. For the front end alone, you'd set up a React app, configure your build tool, and then figure out where to host it. Then for the back end, you'd either spin up a server or write serverless functions somewhere else, and now you've got to connect those two together. Then comes the database. You'd go to something like Superbase or Firebase, create tables, manage API keys, and wire those into your back end. That's already three separate pieces, and we haven't even touched the Discord bot yet. For the bot, you'd go through the Discord developer portal, create an application, generate tokens, set permissions, and then host that bot somewhere so it can actually listen for messages. After that, you still need to connect it back to your back end so replies update your database correctly. So, even for a relatively simple app like this, you're dealing with multiple services, multiple dashboards, and a lot of glue code just to make everything talk to each other.

[00:13:26]With Claude Code and Fling, all of that gets compressed into one workflow. You describe the app, Claude builds each piece, and Fling already knows how to run and connect everything together. The biggest difference is you're not thinking about infrastructure at all.

[00:13:39]You're just thinking about behavior.

[00:13:41]What should happen when a user submits a question, what should happen when you reply, and how that should show up on the site. And because deployment is built in, you're always working against a live version of the app. So, instead of spending most of your time setting things up, you're just iterating on the actual product, which is honestly how this kind of workflow should feel. All right, so if you want to try this yourself, the nice thing right now is that Fling is still in beta, which means you can actually use it for free. Fling will just ask you to sign up via from Claude Code, and that's it. For small projects like this, that's more than enough to experiment and get something live. Long term, they said there's going to be a free tier with some limits like smaller database size and request limits, and then paid tiers if you need more scale. But, the whole idea is to keep it affordable, especially for these kinds of small tools or personal projects. So, if you're already using Claude Code, this is one of those things that's really easy to just try. You don't need to migrate anything or set up a bunch of accounts, you can literally go from idea to a live app in one session. And honestly, even if you don't end up using it long term, it's worth trying just to see what this kind of workflow feels like when deployment is basically built into the coding process.

[00:14:47]If you want to build this exact app or just try your own ideas, head over to flingit.io and start flinging. That's about it for this video. If you found this useful, make sure to like and subscribe, and I'll see you in the next one.