[00:00] (0.16s)
What if I told you there's a $20 monthly
[00:02] (2.72s)
investment that could change how you
[00:04] (4.56s)
think about building apps? While most
[00:06] (6.32s)
people assume you need years of coding
[00:08] (8.40s)
experience to build anything worthwhile,
[00:10] (10.56s)
AI has completely changed the game. You
[00:12] (12.72s)
can now build professional apps that
[00:14] (14.40s)
generate real revenue using nothing but
[00:16] (16.48s)
plain English. Tools like Cursor and
[00:18] (18.64s)
Claude Code for just $20 a month have
[00:21] (21.12s)
turned English into a programming
[00:22] (22.72s)
language. Apps that used to require
[00:24] (24.56s)
teams of developers and months of work,
[00:26] (26.72s)
you can now build them in weeks by
[00:28] (28.48s)
yourself with zero coding background.
[00:30] (30.72s)
But here's the honest truth. You can't
[00:32] (32.32s)
just throw a prompt at these tools and
[00:34] (34.24s)
expect perfect results. There's a
[00:36] (36.16s)
specific workflow that makes the
[00:37] (37.84s)
difference between actually building
[00:39] (39.52s)
something useful versus getting
[00:41] (41.20s)
frustrated with messy outputs. I've
[00:43] (43.28s)
figured out this process through trial
[00:44] (44.96s)
and error, and I want to share exactly
[00:46] (46.80s)
what works. I'm going to walk you
[00:48] (48.48s)
through the complete step-by-step
[00:50] (50.16s)
approach that lets you turn app ideas
[00:52] (52.24s)
into real working products. Even simple
[00:54] (54.64s)
apps like this can generate thousands
[00:56] (56.56s)
when you focus on good design and user
[00:58] (58.80s)
experience. By the end of this video,
[01:00] (60.72s)
you'll have the complete AI builder
[01:02] (62.56s)
playbook. The exact step-by-step system
[01:04] (64.80s)
I use to turn ideas into working apps.
[01:07] (67.52s)
Let me show you how it works. Meet Sage,
[01:10] (70.08s)
the productivity app that actually makes
[01:12] (72.16s)
you want to complete your tasks. This
[01:14] (74.16s)
isn't just a demo. It's a fully working
[01:16] (76.32s)
app where real users can actually create
[01:18] (78.48s)
accounts, log in securely, and have
[01:20] (80.48s)
their data safely stored in our
[01:22] (82.32s)
database. But for now, we can also
[01:24] (84.32s)
choose to continue as a guest and go
[01:26] (86.32s)
straight into the app. Here's how Sage
[01:28] (88.56s)
works. You add daily tasks and assign
[01:30] (90.88s)
point values based on their importance.
[01:32] (92.96s)
As you complete tasks, the progress bar
[01:34] (94.96s)
updates in real time. Complete over 50%
[01:37] (97.68s)
of your points, it turns blue. Hit over
[01:39] (99.84s)
90%, you earn the purple achievement.
[01:42] (102.16s)
Each day gets logged on your calendar
[01:44] (104.16s)
with the color you achieved. This
[01:46] (106.00s)
creates a visual streak that motivates
[01:48] (108.16s)
you to hit purple every day. It gifies
[01:50] (110.88s)
your productivity making daily goals
[01:53] (113.28s)
actually satisfying to complete. Now
[01:55] (115.52s)
let's check out the workflow. So the
[01:57] (117.84s)
first step in this workflow is ideation.
[02:00] (120.40s)
If you already know what you want to
[02:02] (122.00s)
build, you can skip this part. But
[02:04] (124.00s)
essentially you use chat GPT or claude
[02:06] (126.72s)
and you want to be as specific and
[02:08] (128.64s)
direct as you can. As you can see, I
[02:10] (130.88s)
told it I wanted an iOS app and it
[02:13] (133.20s)
should be a productivity app and gave it
[02:15] (135.20s)
further instructions as well. It started
[02:17] (137.20s)
spitting out ideas and I had a natural
[02:19] (139.52s)
conversation with it. That's when I
[02:21] (141.20s)
decided to take a simple concept and
[02:23] (143.36s)
implement gamification because
[02:25] (145.20s)
completing tasks boosts your dopamine
[02:27] (147.60s)
and keeps you wanting to do more. That's
[02:29] (149.60s)
why productivity apps are such a hit. I
[02:32] (152.00s)
had another source of inspiration, an
[02:34] (154.08s)
app that took GitHub's heat map concept
[02:36] (156.32s)
and implemented it in a habit tracker.
[02:38] (158.56s)
amazing app. I wanted something similar.
[02:40] (160.96s)
So, I told Claude to use that as
[02:42] (162.80s)
inspiration. Gave it more instructions
[02:44] (164.88s)
and refined the direction toward the app
[02:46] (166.88s)
you just saw. After discussing more, I
[02:49] (169.04s)
arrived at the MVP structure, which
[02:51] (171.12s)
leads to the next step. Before that, I
[02:53] (173.28s)
also asked Claude for app names and icon
[02:55] (175.68s)
ideas. It gave suggestions. I said I
[02:58] (178.08s)
wanted something personalized and
[02:59] (179.68s)
eventually landed on Sage, which I think
[03:01] (181.76s)
is perfect. Now, the new AI image
[03:04] (184.16s)
generation models are incredible. I
[03:06] (186.16s)
initially thought about making a
[03:07] (187.52s)
tumbleeed icon, but it didn't fit the
[03:09] (189.60s)
theme. Still, you can create amazing
[03:11] (191.60s)
logos with precise variations that
[03:13] (193.76s)
follow your directions perfectly. Any
[03:15] (195.76s)
type of artwork, you don't need graphic
[03:17] (197.76s)
designers anymore. Other models aren't
[03:19] (199.68s)
that great, but OpenAI's new image gen
[03:22] (202.24s)
model is really amazing. I used it for
[03:24] (204.56s)
the icon you saw in the app. Oh, and if
[03:27] (207.12s)
you're enjoying the content we're
[03:28] (208.56s)
making, I'd really appreciate it if you
[03:30] (210.48s)
hit that subscribe button. We're also
[03:32] (212.32s)
testing out channel memberships.
[03:34] (214.00s)
launched the first tier as a test and 79
[03:36] (216.64s)
people have joined so far. The support's
[03:38] (218.72s)
been incredible, so we're thinking about
[03:40] (220.64s)
launching additional tiers. Right now,
[03:42] (222.88s)
members get priority replies to your
[03:44] (224.96s)
comments. Perfect if you need feedback
[03:46] (226.80s)
or have questions. The next step is
[03:49] (229.12s)
making the structure of the MVP of your
[03:51] (231.36s)
app. MVP just means minimum viable
[03:54] (234.40s)
product. It's the most basic version of
[03:56] (236.48s)
your app that fulfills the core idea
[03:58] (238.56s)
you're trying to test out, so you can
[04:00] (240.40s)
test it quickly and validate your
[04:02] (242.24s)
concept. I asked Claude to make three
[04:04] (244.16s)
pages which it had already discussed
[04:06] (246.00s)
earlier in the chat. After it did that,
[04:07] (247.92s)
I took the output, told it to add user
[04:10] (250.16s)
login and a cover page and it added
[04:12] (252.16s)
those as well. Then I had to do some
[04:13] (253.84s)
rethinking and take out elements it
[04:15] (255.76s)
randomly included. That brought me to my
[04:17] (257.84s)
final MVP structure which I copied.
[04:20] (260.16s)
Next, I went into cursor, created a docs
[04:22] (262.56s)
folder, and made a structure.md file
[04:25] (265.04s)
where I pasted everything Claude gave
[04:26] (266.96s)
me. This forms the basis for our next
[04:29] (269.04s)
step. Before we move on, I highly
[04:31] (271.12s)
recommend using Git for your project
[04:33] (273.04s)
because it tracks changes. I made
[04:34] (274.96s)
specific commits at each step, which is
[04:37] (277.04s)
what's allowing me to show you how I
[04:38] (278.88s)
built the app at each stage. If you
[04:40] (280.80s)
don't know Git or programming, no
[04:42] (282.72s)
problem. Just ask your coding agent and
[04:44] (284.88s)
they'll handle it perfectly for you.
[04:47] (287.04s)
Moving on to the third step, creating
[04:49] (289.04s)
your first initial prototype. Take the
[04:51] (291.20s)
MVP structure you made and ask your
[04:53] (293.44s)
coding agent, whether it's claude code,
[04:55] (295.60s)
cursor, or something else, to build a
[04:57] (297.76s)
prototype. Here's the important part. It
[04:59] (299.76s)
needs to be in HTML. That's because AI
[05:02] (302.48s)
agents don't have to do much work to
[05:04] (304.32s)
build it. No extra dependencies,
[05:06] (306.40s)
nothing. It's the simplest way to create
[05:08] (308.24s)
your first prototype. So, I got to work
[05:10] (310.40s)
and it came up with this initial
[05:12] (312.00s)
prototype. It followed the structure.md
[05:14] (314.64s)
really well because HTML is the simplest
[05:17] (317.04s)
language for AI to output. Now, when I
[05:19] (319.44s)
first got the prototype, even though
[05:21] (321.20s)
everything was there on the page, it
[05:23] (323.12s)
wasn't laid out how I wanted. For
[05:25] (325.04s)
example, there was just a small progress
[05:26] (326.96s)
bar, but I wanted a full widget. The
[05:28] (328.96s)
structure was technically there, but not
[05:30] (330.80s)
the way I wanted it to look. At this
[05:32] (332.56s)
point, you need to perfect how you want
[05:34] (334.48s)
the app structured. I'm not talking
[05:36] (336.16s)
about design, just structure. Whether
[05:38] (338.16s)
you want buttons, plain text, full
[05:40] (340.08s)
widgets, or progress bars. Decide that.
[05:42] (342.32s)
Now, I went back and told the agent
[05:44] (344.32s)
exactly how it should be. I even used
[05:46] (346.48s)
screenshots and said, "This is not how
[05:48] (348.32s)
it's supposed to be. It should be this
[05:50] (350.16s)
way. You need to perfect the structure
[05:52] (352.00s)
at this prototype stage." Again,
[05:54] (354.16s)
structure, not colors or design that
[05:56] (356.48s)
comes later. Now, the next step is
[05:58] (358.96s)
actually making your app look good. This
[06:01] (361.04s)
is about the design.json file you see
[06:03] (363.60s)
here. It's a way to style the structure
[06:05] (365.44s)
you've already made and give it proper
[06:07] (367.36s)
design. You can manually design every
[06:09] (369.52s)
component one by one. But there's a
[06:11] (371.44s)
better method I've covered before. You
[06:13] (373.20s)
take a picture or UI inspiration you
[06:15] (375.20s)
like. Give ChatGpt a specific prompt and
[06:17] (377.68s)
it creates a JSON file with all the
[06:19] (379.60s)
visual data to replicate that design.
[06:21] (381.92s)
place it in your directory and you can
[06:23] (383.76s)
style your app based on that
[06:25] (385.20s)
inspiration. I've tested this many
[06:27] (387.04s)
times. It works really well. Here's the
[06:28] (388.80s)
prompt I used. I told it to look at the
[06:30] (390.72s)
design.json implemented on the HTML
[06:33] (393.52s)
prototype, but restricted it from
[06:35] (395.28s)
changing the layout because we're
[06:36] (396.72s)
already done with layout and don't want
[06:38] (398.40s)
that changed. This created the new
[06:40] (400.16s)
redesign based on the colors it picked
[06:42] (402.08s)
up from my inspiration. You can see it's
[06:43] (403.92s)
much better fully colored now and even
[06:45] (405.92s)
the settings page looks decent. Now,
[06:47] (407.76s)
here's an important lesson. You need to
[06:49] (409.52s)
finalize your colors and other design
[06:51] (411.84s)
elements that you want implemented at
[06:53] (413.92s)
this stage. Not animations or 3D
[06:56] (416.24s)
effects. Those come later. Not how the
[06:58] (418.32s)
app feels to use, but how it looks. I
[07:00] (420.48s)
made this mistake and had to redesign
[07:02] (422.48s)
later while building the iOS app. What
[07:04] (424.56s)
could have taken 5 hours took seven
[07:06] (426.64s)
because I had to go back and fix small
[07:08] (428.56s)
things I didn't like. Finalize how the
[07:10] (430.56s)
app will look at this stage. HTML format
[07:12] (432.96s)
is perfect for this because LLMs can
[07:14] (434.96s)
easily follow your lead and make designs
[07:16] (436.96s)
look exactly how you want. Now the fifth
[07:19] (439.68s)
step is conversion. I needed to convert
[07:22] (442.00s)
this HTML prototype into an actual
[07:24] (444.56s)
working iOS app. You can convert from
[07:26] (446.72s)
HTML into pretty much any framework
[07:29] (449.12s)
using this method. All frameworks have
[07:31] (451.20s)
templates. Nex.js is basically a
[07:33] (453.28s)
template. And for iOS apps, you can get
[07:35] (455.44s)
template apps in Xcode as well. I got an
[07:37] (457.68s)
iOS app template, went back to Claude
[07:39] (459.76s)
and explained my situation, how I needed
[07:41] (461.84s)
to convert one file format into another.
[07:44] (464.16s)
I specified the formats and told it to
[07:46] (466.24s)
give me conversion rules. You can also
[07:48] (468.24s)
enable web search if you're using less
[07:50] (470.48s)
known frameworks. It gives you amazing
[07:52] (472.48s)
rules that your agent can follow. I put
[07:54] (474.72s)
those rules into cursor rules and set
[07:56] (476.80s)
them to be followed. I told it to
[07:58] (478.48s)
convert the HTML Sage prototype into an
[08:01] (481.28s)
iOS Swift app using Swift UI. At the
[08:03] (483.84s)
top, I referenced the rule file from
[08:05] (485.52s)
Claude and it converted beautifully. I
[08:07] (487.76s)
didn't really have to do anything. It
[08:09] (489.36s)
replicated the designs and kept the
[08:11] (491.36s)
pages exactly the same. The components
[08:13] (493.44s)
were slightly different because of the
[08:15] (495.04s)
iOS interface, but they still looked
[08:17] (497.04s)
good. You can see the UI that was
[08:18] (498.88s)
implemented. There are some small
[08:20] (500.48s)
changes here and there, but overall it
[08:22] (502.72s)
was a complete working app. Now that our
[08:24] (504.80s)
app was complete, the next step was
[08:26] (506.64s)
implementing the backend and database to
[08:28] (508.88s)
turn it into a real working app with
[08:30] (510.88s)
persistent data that wouldn't disappear
[08:32] (512.96s)
and could handle different users with
[08:34] (514.80s)
separate data. So the sixth step is
[08:37] (517.12s)
building the backend and database. Now
[08:39] (519.20s)
in my case, my app didn't really need a
[08:41] (521.28s)
separate backend. It was already built
[08:43] (523.12s)
right into the Swift app as part of the
[08:45] (525.20s)
prototype. So, the app was already
[08:46] (526.72s)
working, but I did need a database to
[08:48] (528.88s)
store all the data and authentication so
[08:51] (531.28s)
users could securely keep their data
[08:53] (533.28s)
linked to their account. For that, I
[08:55] (535.12s)
went with Superbase. Superbase is super
[08:57] (537.60s)
easy to integrate. You don't even have
[08:59] (539.36s)
to host it yourself. It's all hosted on
[09:01] (541.44s)
their platform, and they give you three
[09:03] (543.12s)
free projects to work with. But here's
[09:04] (544.88s)
the crazy part, and this is honestly the
[09:06] (546.80s)
best part. You literally have to do zero
[09:09] (549.04s)
work to set up the database and
[09:10] (550.88s)
authentication. And that's all thanks to
[09:12] (552.88s)
their MCP server, which just does
[09:14] (554.96s)
everything for you. When you add this
[09:16] (556.64s)
MCP, you get access to tons of tools.
[09:19] (559.36s)
It'll even create the project for you.
[09:21] (561.20s)
Before this, you had to write SQL
[09:23] (563.28s)
commands yourself and paste them into
[09:25] (565.20s)
Superbase manually. Now, they've got a
[09:27] (567.20s)
tool that does it all. You literally
[09:28] (568.96s)
just sit back and watch it happen. So, I
[09:31] (571.04s)
told it to integrate the app with
[09:32] (572.72s)
Superbase using their MCP. I also
[09:35] (575.20s)
created this data structures file in my
[09:37] (577.12s)
docs and had Cursor scan the Sage app to
[09:39] (579.52s)
figure out what database tables I'd
[09:41] (581.36s)
need. When it came time to actually
[09:43] (583.12s)
implement everything, Cursor just went
[09:45] (585.12s)
ahead and did it all. Called the MCP,
[09:47] (587.60s)
created the database, installed the
[09:49] (589.44s)
Superbase SDK, and handled the entire
[09:52] (592.08s)
integration in about 15 minutes. That's
[09:54] (594.32s)
how fast I got authentication and
[09:56] (596.16s)
backend setup. Now the app has full
[09:58] (598.24s)
login functionality. It's become a real
[10:00] (600.64s)
fully working app with actual database
[10:02] (602.80s)
and authentication. The only thing left
[10:05] (605.12s)
was making the app actually look good.
[10:07] (607.20s)
You can see the app looks so much better
[10:09] (609.04s)
now compared to the initial prototype
[10:11] (611.12s)
and even the converted app. That's
[10:12] (612.96s)
because I had to go back into cursor and
[10:14] (614.96s)
make tons of changes. When I wanted
[10:16] (616.80s)
animations, cursor couldn't really help.
[10:18] (618.96s)
So, I switched to clawed code since it's
[10:21] (621.12s)
better at complex thinking tasks. Here's
[10:23] (623.28s)
the reality. If you want good apps,
[10:25] (625.28s)
refining the UI takes the most time.
[10:27] (627.52s)
This has taken me about 3 hours so far.
[10:29] (629.76s)
For a perfect app could take a week or
[10:31] (631.76s)
more. Without AI though, this would have
[10:33] (633.60s)
been a month, maybe two. You can't just
[10:35] (635.52s)
type one prompt into AI app builders and
[10:38] (638.08s)
expect amazing UI. You have to build it
[10:40] (640.32s)
yourself. I'll be honest, the UI is good
[10:42] (642.48s)
right now. Not great. I'm still
[10:44] (644.16s)
iterating on it. That simple animation
[10:46] (646.24s)
took me 20 minutes, but I think it looks
[10:48] (648.32s)
really good. I also added color changes
[10:50] (650.64s)
based on progress. Still working on the
[10:52] (652.72s)
calendar and settings. This is how you
[10:54] (654.56s)
make apps with good UI. There's no
[10:56] (656.56s)
single prompt that does it all. You need
[10:58] (658.72s)
to add those small details that make it
[11:00] (660.80s)
perfect. I used chat GPT to create the
[11:03] (663.44s)
icon. I uploaded the basic icon from the
[11:05] (665.92s)
HTML prototype, gave it instructions to
[11:08] (668.56s)
improve it, and it generated this
[11:10] (670.32s)
version that I really love. It's all
[11:12] (672.08s)
about the instructions you give it. This
[11:13] (673.76s)
chat GPT model is crazy good. Then I
[11:16] (676.16s)
just went into Xcode's assets folder and
[11:18] (678.48s)
dragged and dropped the icon. Super
[11:20] (680.48s)
easy. You can also add versions for dark
[11:22] (682.64s)
mode or tinted versions. After this
[11:24] (684.72s)
whole process, iteration is the most
[11:26] (686.80s)
important step, the time you spend
[11:28] (688.56s)
perfecting it. You can get the logic and
[11:30] (690.64s)
layout close from the start, but what
[11:32] (692.40s)
makes an app look good are the
[11:34] (694.00s)
animations, tweaks, and subtle effects.
[11:36] (696.32s)
You've got to spend time on those
[11:37] (697.84s)
finishing touches. That's what creates
[11:39] (699.84s)
apps capable of making real money. That
[11:42] (702.48s)
brings us to the end of this video. If
[11:44] (704.24s)
you'd like to support the channel and
[11:45] (705.84s)
help us keep making videos like this,
[11:47] (707.84s)
you can do so by using the superthanks
[11:49] (709.84s)
button below. As always, thank you for
[11:51] (711.76s)
watching and I'll see you in the next