What this covers
Chris walks through the practical workflow of building an iOS app using Windsurf, an AI-assisted IDE, from initial concept through a working prototype. The video covers setup (installing extensions, packages, and the MCP server for external tool integration), idea validation using keyword research, UI design generation, and then the core development loop: prompting the AI to write code, debugging what it produces, and iterating toward a finished app. The underlying argument is pragmatic: AI gets you roughly 80% of the way to a working app very quickly, but the remaining 20%—precise UI matching, fixing duplicated code, resolving build errors—remains slow and finicky work that demands at least basic Swift knowledge and disciplined process to navigate efficiently.
The video emphasizes several friction points and remedies. AI tends to duplicate declarations, produce roundabout fixes when asked to debug its own errors, and struggle with granular UI precision; Chris shows how to work around these by writing detailed step-by-step instructions and global rules for the AI to follow, scoping each conversation to one task, and using screenshots with debug logs to pinpoint UI divergence. He stresses that source control setup can wait—beginners should simply duplicate the project folder as a backup with notes, since Windsurf can corrupt projects irreversibly and a low-tech checkpoint is faster than learning Git. The workflow also includes practical detours: keyword research to find app ideas with low competition, generating requirements and designs before coding begins, and knowing when to revert and restart rather than letting the AI spiral further from a working solution. Throughout, the lesson is that AI coding is a force multiplier for developers who already know the fundamentals, not a replacement for judgment.
AI-assisted iOS app development with Windsurf can get you ~80% of the way to a working app quickly, but you still need basic Swift knowledge and disciplined process (rules, instructions, backups) because the AI frequently introduces errors and struggles with precise UI work.
- AI duplicates code and produces build errors that require manual debugging knowledge to fix efficiently
- AI gets you 80% there fast but the last 20% (precise UI matching) is slow and finicky
- Source control or low-tech folder backups are essential because the AI can corrupt projects irreversibly
This asset isn't compiled yet
You're seeing its claims, ranked. Compile it to build the argument threads, weight them, and check each claim against your library — the full view.
Providing the AI a step-by-step instructions/requirements file (an instructions.md generated by the same AI that holds context of prior planning) and having it build the app feature-by-feature keeps development controlled and incremental.
“we want to specify a set of requirements for our project and have the AI follow it step by step. So, building out feature by feature.”
Specifying global rules for the AI (collected from experienced practitioners and refined by observing what the AI repeatedly gets wrong) keeps the AI 'on the rails' by constraining its behavior to do things a certain way and avoid known failure modes.
“we want to make sure that we keep it on the rails as much as possible because sometimes it can do a lot of unexpected and unwanted things. One way we can control it is to specify rules.”
Using AI to run simple commands you already know (like checking the Homebrew version) is slower than just typing them yourself, so relying on AI for everything is not always the best option.
“actually would have been faster, right, if you had typed it out yourself. So maybe using AI for everything is not the best option.”
AI coding gets you about 80% of the way to a working app very quickly, but the remaining nitpicking on small details is hard and time-consuming, so AI changes how you spend your time rather than eliminating the time required.
“you can get 80% of the way there really quickly, but then nitpicking it on little things. It's just really hard to do or it takes a lot of time to do.”
You need at least basic Swift knowledge (how to declare structs and classes, navigate Xcode, find-and-replace duplicates) to debug AI-generated iOS code efficiently; without it, beginners would struggle, and asking the AI to fix its own errors tends to produce roundabout, often wrong solutions.
“If you don't know that basic syntax, you wouldn't be able to even do what I'm doing right now. But to anyone who has even spent a little bit of time with Swift, they can understand what I'm doing right now”
Each AI conversation should be scoped to one task — after a bug is fixed, start a new conversation so the AI doesn't carry irrelevant prior context into the next problem.
“one tip is that each conversation should be related to one thing. So, if you're fixing a bug after it's fixed it, start a new conversation so it doesn't carry the context of what we were working on before.”
When debugging UI behavior with AI, you can give it a screenshot from the simulator and have it add debugging statements so it can read the debug log, trace the exact sequence of UI interactions, and identify where output diverges from expectation.
“you can tell AI to add debugging statements... you can say look at the sequence of events that I've done interacting with the UI and the output is not what I expected. So, it will be able to read this log and be able to trace exactly how you've been interacting with the app”
Targeting app keywords with low competition (below 50) but decent popularity (above 20), using a keyword tool like Astro, lets developers capture organic App Store traffic and reduce reliance on marketing.
“this allows me to look for low competition but decent traffic keywords to build apps around to try to capture that organic traffic, which means that we don't have to do as much marketing or maybe even perhaps we can rely on organic app store traffic if the app ranks well”
AI struggles to precisely match a target UI from a screenshot — repeated broad 'match the design' prompts made the UI progressively worse — so achieving an exact design requires very specific, granular instructions rather than broad commands.
“I feel like the UI is worse than it was before. What happened? Is Windsurf blind?... I guess I have to be very specific, right?”
When the AI spirals out of control and gets progressively farther from a working solution, the right move is to stop it and reset (revert the conversation or restore a backup) rather than letting it continue.
“after completely botching up the project, it was just spinning out of control. I decided to stop it because I could see from the way from the things that it was trying that it was just getting farther and farther from it. So let's reset.”
Beginners should avoid setting up source control (Git/GitHub) and instead duplicate the project folder as a backup with notes about the last working state, because source control takes a while to learn and Windsurf may corrupt the project — making a low-tech backup essential.
“it takes a while to set up if it's your first time. Takes a while to wrap your head around. So I wouldn't bother. What I would recommend you instead is literally if you have a working project, just duplicate the folder and there's your backup copy.”
MCP (Model Context Protocol) lets an IDE like Windsurf connect to external tools (databases, Figma, image generation) and bring those capabilities directly into a project, saving time versus manually switching between tools.
“essentially allows your IDE such as Windinssurf to connect to external tools and to be able to use them just bring them directly into your project. So that way it saves time, gives your IDE extra capabilities”
Re-prompting with more specific instructions (reference the instructions steps 3.1 and 3.2, attach the design image, and explicitly tell it to match the image) produced a working, error-free build on the first try, unlike the vaguer earlier prompt.
“let's build step 3.1 and 3.2. From the instructions, follow the image attached. make the UI look like the attached image.”
A repeatable AI-driven app planning workflow is: use AI to identify the primary problem a keyword's apps solve, pick one core feature for a fast launch, assess monetization, sketch a V2/V3/V4 roadmap, define a user flow, then break that into per-screen descriptions feedable to a UI design tool like UX Pilot.
“I want to build an app that satisfies the search intent. So someone's searching for money counter I want to understand what it is that they're looking for and the app that I'm building should solve that problem.”
Windsurf can be configured for iOS development as a near-Xcode replacement by installing the Swift and Sweetpad VS Code extensions plus Homebrew packages (Xcode build server, iOS deploy, XCBeautify, Swift format), because Windsurf is built off Visual Studio Code and thus supports VS Code extensions.
“we're using Windsurf is because Windsurf is built off of Visual Studio as far as I understand. And that's why all these Visual Studio extensions also work here.”
Connecting an OpenAI/DALL-E image-generation tool via MCP lets Windsurf generate images and pull them into the project automatically, eliminating the manual workflow of opening DALL-E separately, prompting, downloading, and importing.
“because you don't have to go open Deli in a separate tab prompted generate images download it to your desktop and import it into your project. With this tool called Windinsurf will be able to generate the image immediately and then just pull it into the project automatically.”
The AI-generated code produced build errors by declaring the same struct (e.g., 'denomination') twice and dumping duplicate code into the ContentView, which the developer fixed by manually deleting the duplicate declarations rather than asking the AI to fix it.
“denomination is ambiguous... Look, it declared it twice. So here is one and it declared it here as well. So that's why it is erroring out.”
Windsurf's 'revert' on a past conversation does not undo folders/files the AI created, so it cannot fully restore the project — which is why an independent backup is necessary.
“even though I hit revert, it still it created like all the folders are still there. So, I guess I can't revert the folders that it created.”
A money counter app should not charge a subscription because competitors who have already researched this don't, and it is a one-off utility tool without ongoing cost, so a subscription model doesn't fit even though subscriptions generate more revenue.
“It's not likely that I could charge a subscription for this because many people competitors who have probably done this research already are not charging subscriptions and it really doesn't make sense in this case cuz it it's uh more of a utility, a tool that doesn't have ongoing cost”
Learning Swift and SwiftUI basics — roughly a 30-day investment — will let you use AI coding tools far more effectively and save time in the long run if you intend to build apps for a while.
“just like a 30-day investment to get this baseline of knowledge for Swift and Swift UI will help you use these tools a lot more effectively and save you time in the long run”
You should prioritize getting working functionality before nitpicking the UI when building with AI.
“typically we'll focus on working getting working functionality before nitpicking about the UI”
Up to the design stage the process required no real thinking — just passing information from one AI tool to the next — but actual development still requires the developer's own judgment.
“keep in mind right now I've literally just been typing prompts. I have not been using my brain at all so far. Just passing information from one tool to the next.”
UX Pilot designs generated purely from AI-described screens are not impressive but are good enough for a V1 prototype-quality app that can be launched and then iteratively improved.
“these designs aren't crazy, but I feel like they are good enough to do like a V1, like a very prototypy type of app that you can launch and then iteratively improve upon it”
A single-column denomination layout might be a better money-counting UI than a two-column scrolling layout because it avoids scrolling, though the two-column risks accidental taps while the single-column is clearer.
“if I were counting money, right, this would be a better user interface than this one... Because I wouldn't want to scroll up and down to find the denomination. I would rather see more denominations at once and just reduce having to scroll.”
Apple is incorporating an AI assistant (reportedly Claude) into Xcode.
“as of this recording, Apple is incorporating something into Xcode. I think it's claude, was it?”