Vibe Coding Tutorial: How to Actually Make Money with Building Apps (No Code + AI)

Have you ever wondered how people are making hundreds of thousands of dollars every single month just by building simple apps without writing a single line of code? Well, in this video, I'm

going to reveal to you the exact step-by-step process that I use to build profitable apps using nothing but AI tools. And now, most people think you

tools. And now, most people think you need years of coding experience or a computer science degree to create apps that actually make money, right? No,

that's completely wrong. Now, I'm going to show you how to build an app without writing a single line of code. And we're

going to build a rock identification app that helps users identify different types of stones and minerals using their phone camera. The app provides detailed

phone camera. The app provides detailed information about geological specimens and their properties. And in this screenshot that you can see here, it's proof that apps like this are generating

over $400,000 last month from the app store alone. But

here's what I've never revealed on my channel before. I'm not just going to

channel before. I'm not just going to show you how to build the app using the best AI coding tool available right now, where you literally just prop your idea

and the AI builds your entire app. I'm

also going to walk you through the complete process of getting your AI built app into the app store without any of the complicated technical processes that usually stop people. so that by the

end of this video, you're going to have everything you need to copy this exact app concept, build it with AI in minutes, and get it live on the App Store. So, if you've ever wanted to tap

Store. So, if you've ever wanted to tap into the app economy, but you always thought it was too technical or complicated, well, this video is going to change everything for you. Let's dive

right in. All righty. So, in this video, we're going to go step by step using B 44 and Despia. Base 44 to build the app with AI and Despia to easily submit the app to the app store. I added a special

link in the description down below that you can scroll to for both of those tools. Now, before an app can identify

tools. Now, before an app can identify anything, rocks, minerals, or otherwise, it needs a solid layout to hold all of its features. So, we're starting by

its features. So, we're starting by putting together the front end. And

think of this as setting up the frame of the app before we bring in all the powerful tools. And once the structure

powerful tools. And once the structure is in place, everything else becomes easier to build and easier for the user to navigate. So to get started on all of

to navigate. So to get started on all of that, I'm going to give base 44 this prompt. Create a responsive rock

prompt. Create a responsive rock identifier app. First, please build the

identifier app. First, please build the front end/UI. Create a dashboard history

front end/UI. Create a dashboard history and settings section. Add a navbar at the bottom. And don't build any

the bottom. And don't build any functionality yet, just the UI. And Base

44 generates our layout. And right away, the app takes shape. A clean dashboard, a dedicated history section, and a simple settings page. All connected by a bottom navigation bar here. It's not

functional yet, but visually it already feels like a real app. And here you'll see the UI fully rendered and ready for the next step, which is building out the photo upload interface so that our users

can start sending images into the system. The next step is to give the app

system. The next step is to give the app a way to actually receive images. Since

the entire point of the rock identifier is scanning photos, we do need a clean and simple upload flow that lets our users either choose an existing picture or take one instantly with their device.

The UI from the previous step is already in place. So now we're just going to

in place. So now we're just going to build the feature that makes the dashboard interactive. So let's give

dashboard interactive. So let's give base 44 this prompt to set this up.

Update the dashboard and build the upload functionality. Also add support

upload functionality. Also add support for taking photos. Whenever an image is taken or uploaded, show a preview of the image before analyzing. Create an

analyze rock button to trigger the analyzing function. Only build the

analyzing function. Only build the upload functionality for now, not the analyzing function itself. After B 44 completes the update, the app can now handle photo uploads and even take

pictures directly from the device. And

the moment a user selects an image, a preview appears immediately here, giving them a clear look at what's about to be analyzed. Let's test it out with a

analyzed. Let's test it out with a simple rock photo. And there you go.

That shows everything loads smoothly.

And the interface responds exactly the way it should. Again, there's still no analyzing capabilities just yet. That's

what we will build next. But the upload flow is now fully working and ready for the AI system will add in the upcoming step. So, right now the app can upload

step. So, right now the app can upload pictures just fine, but that only gets us about halfway there, if even. What

makes a rock identifier actually useful is its ability to recognize what's in the photo. So, it's time now to add the

the photo. So, it's time now to add the AI feature that analyzes each image and returns detailed information. Moving

forward, I am going to ask B 44 to build out the entire identification system.

Please build the AI powered rock identification feature. Utilize your own

identification feature. Utilize your own AI for the functionality. Whenever

scanning a rock, show the scanned results in a modal that includes the common and scientific name of the rock or mineral, its basic classification,

physical properties, formation process, common location, collecting values and fun facts. Furthermore, ensure the

fun facts. Furthermore, ensure the scanning functionality is advanced as it can analyze the photo from different angles and multiple views. After Base 44 finishes building the feature, the

uploader turns into a full scanning system. The moment a rock image is

system. The moment a rock image is analyzed, the app now opens a modal loaded with everything the user needs.

Names classifications properties formation details, common locations, even collecting value and of course some fun facts. It's a complete breakdown in

fun facts. It's a complete breakdown in just one scan and it works exactly as intended. We can see here that the

intended. We can see here that the results came through, which means the identification system is officially working. At this point, the app can

working. At this point, the app can identify rocks really well, but users need a way to keep track of what they've scanned. So, the next step is to build a

scanned. So, the next step is to build a proper saving system, something that lets people store their identified rocks to organize them, and then build a personal collection over time. I'm going

to ask B 44 to create the full saving and collection management flow with this prompt. Build the saving functionality

prompt. Build the saving functionality of the application. Whenever a scan result is saved, allow the user to save it to their collections. Build a new section for this. And then make sure

there's a navbar as well. In the

collection management, allow the user to save notes, set the location, and other filters that can help the user organize their collection. And once B 44 finishes

their collection. And once B 44 finishes up with that prompt and generating the update, the app gains an entirely new collection section here. Any identified

rock can now be saved and the user can open it later to add notes, tag it, set a location, and also apply filters to keep things organized. It turns the app from a simple scanner to something much

more personal and useful. And after

testing it with the same sample rock as before, the saved entry appears here in the new collections tab exactly as expected. The editable fields work

expected. The editable fields work smoothly and organization tools are already in place. Now, this sets us up for the next feature, adding advanced search filters to make collections even

easier to navigate. Of course,

collections can grow quickly. So, this

next upgrade is all about helping our users stay organized. And once someone has like dozens of saved rocks, if not more, scrolling through them, everything manually becomes messy. So, in order to

fix that, we're going to add a proper search bar along with filters that make it easy to sort and categorize entries.

I'm going to ask B 44 to build this out using the following instruction. Please

build a search functionality for the collection management and create some filters that the user can add to their collected rocks. Allow the users to be

collected rocks. Allow the users to be able to set some filters as well as to help them categorize their rock collection. Again, after base 44

collection. Again, after base 44 processes the update, the collection page gets a noticeable upgrade. A search

bar appears here at the top, and new filter options let users narrow down their rocks based on whatever category they've set, whether that's tags, types, properties, or anything else that

they've added. It makes navigation and

they've added. It makes navigation and navigating larger collections feel a lot more effortless. So, instead of

more effortless. So, instead of scrolling through a long list, I can now just type in a keyword or activate a filter and the app instantly pulls up the matching entries. It's quick, it's

clean, and makes the whole collection feature feel a lot more practical for everyday use. There's also a fun way to

everyday use. There's also a fun way to make this app feel a lot more personal, and that's by letting it respond to where the user actually is. Raw

collectors in different regions often find completely different minerals. So

adding locationbased suggestions makes the app feel a lot smarter and more useful right away. Now to make that happen, I'm going to use this prompt.

Improve the app by adding a locationbased suggestions widget in the dashboard. Here it detects the user's

dashboard. Here it detects the user's location and suggests the most common type of rocks available. And after base 44 finishes generating the feature, the

app can now automatically detect the user's location and then adjusts its suggestions accordingly. So as soon as

suggestions accordingly. So as soon as permission is granted, the dashboard updates with a list of rocks commonly found in that specific region. It's a

lightweight feature, but it instantly makes the experience feel more relevant and helpful. A lot of people who get

and helpful. A lot of people who get into rock collecting don't just want names and labels now. They want a little bit more. They want to understand what

bit more. They want to understand what they're actually looking at. So the next feature we're building is a full learning section where users can dive into geology topics, rock formation,

mineral properties, and everything else that supports their collecting hobby. So

let's move forward with this section by giving base 44 a prompt that defines how the learn tab should function and what users should be able to explore. Please

create a new learn page containing educational information about rocks.

make sure it's engaging and thorough with its content covering different topics and categories. And once B 44 finishes up generating that update, the

app now gets an entirely new learn tab.

It's organized into different topics with clear explanations, making it easy for users to explore geology concepts at their own pace. And the section is also

packed with useful context and serves as a solid educational companion to the scanning and collection features they're already using. Now before we move

already using. Now before we move everything into Despia, there is one last tweak we need to make inside base 44 because the app is fully built and all the features are in place. But right

now it still requires login to access.

Since we want users to open the app freely once it's published through the app store, I am going to switch that setting off. And then I'll head over to

setting off. And then I'll head over to the publish button in the top right corner of base 44. And from there, I'll open the public access login required panel and simply disable the option that

says require login to access. And once

that's turned off, we can publish the app again and copy the project link.

This is the link we're going to use inside Despia for the final packaging and submission. And that's it. Our base

and submission. And that's it. Our base

44 build is officially ready to move into Despia. And next up, we'll

into Despia. And next up, we'll integrate everything and prepare the app for the app store. All righty then. So,

setting everything up inside Despia is what turns the base 44 project into an actual app that can be published on the app store. So, this step is all about

app store. So, this step is all about getting the foundations in place. And

we're going to start by heading over to Despia's website and then creating a brand new app project. Once the

dashboard loads, the first thing to enter is the app's name, which is rock identifier in this case, and then paste the web app start URL from base 44, so that Despia knows exactly which build

it's working with. After the project is created, we'll move into the branding setup. In the left sidebar here, there's

setup. In the left sidebar here, there's an app icon and branding section where we upload the iOS app icon. SPO requires

a 1024x1024 image, so that needs to be prepared beforehand. And for the sake of

beforehand. And for the sake of demonstration, a simple placeholder icon works fine, too. After that, we're going to scroll down to the splash screen layout area, and drop in the splash

screen GIF, which becomes the quick loading screen that our users see when the app starts up. And once those assets are uploaded, the project has everything

it now needs visually. And from here, we're going to move straight into linking the Apple developer account so that Despia can handle building and submitting the app properly. After

creating the project, the next thing we need to do is link our Apple developer account so that Despia can handle the build and submission process. We do this

from the right side panel here. I'm

going to start by opening the build history section and clicking deploy build which opens the sidebar where all the connection settings live. Inside the

deployment panel, we'll scroll down until we see build configuration. Then

from there, I'll select the development team and choose the option to add a new team. This opens the connect with app

team. This opens the connect with app store connect panel. And this is where we enter all of Apple's required credentials. For the development team

credentials. For the development team ID, we will go to the Apple developer dashboard and open the resources page.

The team ID appears at the top right.

So, we'll just copy it and then paste it back into Despia. Next is the account issuer ID. We'll head to the App Store

issuer ID. We'll head to the App Store Connect integrations page where the issuer ID is displayed right away. And

once we copy that, we'll just paste it back into Despia as well. After that, we have the API key ID and the PA key file.

We'll generate these from App Store Connect by creating a new API key. Any

name works, but of course, in this build, it's going to be labeled rock identifier- Despia. We'll assign it the

identifier- Despia. We'll assign it the app manager role, generate the key, copy the API key ID, and paste it into the connect API key field in Despia. Then,

we'll download the PA key file and upload it into the matching field. And

once all three pieces of information are in place, we can click link with Apple and Despia will connect the account. And

after it's done, we'll return to the build configuration panel and set our development team to the newly linked account. Now, before we can actually

account. Now, before we can actually submit anything to the app store, Despia gives us a checklist of requirements that Apple expects every app to have.

And each item in the list, from app bundles to one signal targets to widgets, represents something Apple needs behind the scenes so the build can pass validation. And the very first item

pass validation. And the very first item on that list is the app bundle, which acts as the app's unique identity inside the Apple ecosystem. Now, to set this up, we'll open the identifier section in

the Apple developer account and create a new identifier. We'll select app ID,

new identifier. We'll select app ID, choose app as a type, and move to the configuration screen. This is where we

configuration screen. This is where we paste the bundle ID that Despia generated earlier. Now for the

generated earlier. Now for the description, we simply name it rock identifier. Next, we are going to enable

identifier. Next, we are going to enable the required capabilities. App test, app groups, associated domains, iCloud with cloudkit support and push notifications

with broadcast capability. And once

those are turned on, we will continue and register the identifier. After

saving it appears in our list and Despia will detect it right away, confirming that the main app bundle is now fully set up. The next item in Despia's

set up. The next item in Despia's checklist is the one signal target which handles push notifications behind the scenes. And to set this up, we start the

scenes. And to set this up, we start the same way as before. In the Apple developer dashboard, we create a new identifier and choose app ID app. Then

we take the push bundle ID from Gaspia and paste it into the bundle ID field.

For the description, we label it clearly so it is easy to recognize later. So for

example, rock identifier one signal.

Once the identifier details are in place, we enable the required capabilities, app groups, associated domains, and push notifications with broadcast capabilities. After that, we

broadcast capabilities. After that, we continue and register the identifier.

And with the one signal app ID created, the next part is setting up the matching app group. We create a new app group

app group. We create a new app group identifier. Paste the push app group ID

identifier. Paste the push app group ID from Despia and name it something like rock identifier one signal app group. So

it is obvious what it belongs to. After

registering the group, we return to the one signal identifier we created earlier. Under the app groups

earlier. Under the app groups capability, we click configure and attach the group we just set up. And

once the changes are saved, the one signal target and its app group are fully linked and ready to use inside of Desp. Now setting up the app clip target

Desp. Now setting up the app clip target is a little different from the earlier identifiers, but the overall flow stays familiar. So this time when creating a

familiar. So this time when creating a new identifier in the Apple developer account, we will start under app ID, but on the next page, we pick app clip instead of the regular app option. Since

an app clip must be tied to the main app, we will select our primary bundle ID rock identifier as the parent app ID, then name the product simply clip.

Before registering it, we do need to add a clear description like rock identifier app clip and enable the capabilities this mini version of the app needs,

namely app groups, associated domains, and push notifications. Once everything

is set, we continue and register the new app clip identifier. After that, we will create the app clips dedicated app group. And just like before, we need to

group. And just like before, we need to grab the clip app group ID from Despia.

Paste it into the identifier field and name it something easy to track like rock identifier app clip app group.

After registering that, the final step is connecting the group back to the app clip identifier. Inside the app clip

clip identifier. Inside the app clip settings, we open the app groups configuration and attach the group we just created. Now, at this point, the

just created. Now, at this point, the app clip and its app group, they're fully linked together and ready for Despia's build process. For the share target setup, we're handling another

small but important identifier that lets the app receive shared content on iOS.

To start, we will take the share target bundle ID from Despia and create a new identifier inside the Apple developer dashboard. Under app ids, we are going

dashboard. Under app ids, we are going to select app paste the bundle ID and add a clear description such as rock identifier share target. This one only

needs app group. So that's the single capability we enable before registering it. And then after the identifier is

it. And then after the identifier is created, we are going to generate its dedicated app group. Now that part involves copying the group ID from Despia, creating a new app group

identifier in Apple developer and then naming it something easy to track like rock identifier share target app group.

Once it is registered, the last step is linking it back to the share target that we just created. And inside the share target settings, we open the app groups configuration and attach the matching

group. The very last identifier we need

group. The very last identifier we need to set up is the smart widget target.

And thankfully, this one follows the same overall flow as the previous configurations. And I'll start by

configurations. And I'll start by copying the smart widget bundle ID from Daspia. Then heading back into Apple's

Daspia. Then heading back into Apple's identifiers page to create a new app ID.

After selecting app, we will paste that bundle ID into the field and give it a clear name. In this case, rock

clear name. In this case, rock identifier widget so it's easy to recognize later on. And once the base ID is registered, we can now enable the app groups capability. Just like with the

groups capability. Just like with the earlier targets, next we need to create the corresponding app group. So using

the group ID provided in Despia, I'll generate a new app group identifier and label it rock identifier widget app group so it's consistent with the rest.

After saving that, the final step is simply connecting all the pieces. So

let's open the smart widget identifier again. Go to the app group section,

again. Go to the app group section, choose configure, and add the new group we just created. And once that's saved, the smart widget setup is complete and

all of our required targets now have their own IDs and groups properly linked. All the individual identifiers

linked. All the individual identifiers and app groups are finally set up. So

the next move is pulling everything together under the main app bundle. And

we're going to head back into the identifier section here in the Apple developer dashboard and open the primary bundle, the very first one we created for Rock identifier. In the app groups

area, we'll hit edit and check every group prepared earlier. That's one

signal, app clip, share, and widget.

After saving those changes, all targets are properly linked to the main app. And

from here, we're going to register the project inside App Store Connect. In the

app section, we'll create a new iOS app.

The details are pretty straightforward.

The name is Rock Identifier. The

language is set to English and the bundle ID selected is the main one from earlier for the SKU. Writing the name in all caps works perfectly. After clicking

create, the app container Apple needs is now ready to go. Inside the newly created app information page, we'll copy the Apple ID assigned to this app. And

then back in Despia, we'll paste that value into the app store app ID field so that everything syncs correctly. And

after that, we're going to publish the project from Despia, which starts the build process and automatically sends the generated IPA file to App Store

Connect. Now, the upload may take a bit

Connect. Now, the upload may take a bit depending on configuration, but once the build appears in Apple's list, that confirms the submission step worked successfully. All right, so reaching

successfully. All right, so reaching this stage always feels like the home stretch. We're almost there. The app is

stretch. We're almost there. The app is built, the features are done, and the Despia build is already uploaded. And

now it's just a matter of getting everything Apple needs before they can actually approve it. And this part is not complicated, but it does involve a handful of small requirements that we'll

have to walk through one by one. And

once those are set, the app is officially ready for review. And the

very first thing we need to take care of is the privacy policy. We're going to generate one using privacy policy generator.info. Infel, I'll select the

generator.info. Infel, I'll select the app option and go through the form step by step. In a real production release,

by step. In a real production release, the answer should accurately reflect how the app handles data. And since this project is only a demo, I am going to

keep things simple and selecting no for the data collection questions. After the

policy is generated, I'll just copy the link so we can use it later during the submission process. Once the privacy

submission process. Once the privacy policy link is ready, we can now move over to the distribution page in App Store Connect. This is where we upload

Store Connect. This is where we upload all the assets Apple requires before a build can be reviewed. And I'll start by dragging in three iPhone screenshots, followed by the iPad versions. Now,

these don't need to be the final design shots for the demo, but in a real submission, you should have clean, accurate screenshots that show your core features clearly. And after the images

features clearly. And after the images are in place, I'm going to fill out the basic metadata, the promotional text set to rock identifier, scan it, a short

description that says rock identifier is an AI powered rock collecting app, and some keywords like scanning rocks hobbies. I'm also going to paste the

hobbies. I'm also going to paste the privacy policy link into the support URL field so that Apple can access it during review. Next, I'll set the version

review. Next, I'll set the version number to 1.0.0 zero to match the configuration from Despia and add the copyright label rock identifier. And

once all that's done, let's scroll down and select the build that Despia submitted earlier. There's a quick

submitted earlier. There's a quick setting under app review information for apps that require a login. And since

this demo doesn't need authentication, I'm just going to uncheck the signin required box. Now, if your app actually

required box. Now, if your app actually needs sign-in functionality, you can leave this enabled and provide credentials. After reviewing everything

credentials. After reviewing everything one last time, let's head back to the top and hit save. Next, I'm going to open the app information section to fill out the remaining details Apple

requires. I'll add a simple subtitle

requires. I'll add a simple subtitle that says scan your minerals, and I'll choose categories that also match the app. Education and lifestyle work well

app. Education and lifestyle work well for this type of project. Since the app doesn't collect any personal data, we'll set the content rights option to no. The

age rating questionnaire comes right after that. And since the app has no

after that. And since the app has no sensitive or explicit content, I'll go through the list and select no for each question. Once everything looks correct,

question. Once everything looks correct, we can now save the changes to lock in the app's information. Next, I'm going to take care of the pricing and availability settings. Now, this part is

availability settings. Now, this part is usually pretty quick, but it's still important because it determines who can actually download the app once it does go live. And since this project is meant

go live. And since this project is meant to be completely free, I'll add a pricing tier and set it to $0. After

that, I'll double check the regional pricing overview just to make sure everything looks right before confirming it. After that, I'll set the app's

it. After that, I'll set the app's availability. I'm going to choose all

availability. I'm going to choose all countries and regions so anyone anywhere can download it without restrictions.

After confirming the full list, the app is officially marked as free and globally accessible. And this wraps up

globally accessible. And this wraps up the pricing and availability setup and gets us one step closer to submitting the build. Now, privacy setup is one of

the build. Now, privacy setup is one of those steps that feels small, but stops a lot of people during their first App Store submission because Apple wants to know exactly what kind of data your app

touches, even if it's something as simple as images processed on device.

Since our Rock identifier works with photo uploads, we'll need to fill this out properly before we can move forward.

And from here, I'll head into the app privacy section and start by adding the privacy policy URL we generated earlier.

After saving that, I'll click get started to go through Apple's data collection questions. And since the app

collection questions. And since the app analyzes photos, I'll select yes when asked whether the app collects data. On

the next screen here, I'll choose image as the data type because that's the only thing this app interacts with. After

stepping through the remaining questions and confirming everything looks correct, at least to me, I'm going to go ahead and save the setup. Once all the privacy information is in place, I'll just hit

publish to finalize the section. Now,

setting the app in for review is the very last checkpoint. And after ensuring that everything is filled out and saved, we'll head back to the prepare for

submission page. And from here, we need

submission page. And from here, we need to click add for review. choose the

build we just configured and submit it.

And that's all it takes. Our rock

identifier app is officially on its way to Apple's review queue. And that's a wrap on all of that. The app is officially built. It's packaged and it's

officially built. It's packaged and it's submitted. This is exactly the kind of

submitted. This is exactly the kind of workflow that people are using to actually make money building apps in 2026 without writing a single line of code. Now, if you can map out an idea

code. Now, if you can map out an idea and guide the AI, you can ship real products. Thank you for investing your

products. Thank you for investing your time here with me today and I'll catch you at the next