Published on: February 6, 2026
AI is changing how we build apps. That’s not news. What might be less obvious is how this shift is forcing us to think differently about what actually matters in development. In this post, I want to share my balanced thoughts on AI-driven coding. I’d like to give you my perspective on why tons of new apps on the store isn’t as scary as it might seem, and how AI is making iteration cheaper than ever. I’d also like to explore how the human touch separates polished products from vibe-coded slop when your driven by providing a good UX and doing proper user research.
By the end, you’ll hopefully be able to make up your own mind on how AI is changing what development means to us.
AI slop and the idea glut
Over the past months, there’s been a huge increase in apps being submitted to the App Store. Most of these apps are vibe-coded, built super quickly, and shipped to the store as soon as possible (and often come with a subscription).
To some, this proves that development is now easy. Anybody can convert their ideas into apps in a day. To me, it just proves that ideas were always cheap. Ideas were never the differentiator of what makes an app great. It was always execution.
Before AI, anyone could have an idea for an app. The barrier was building it. Now AI has lowered that barrier significantly, so more ideas are making it to the store. But that doesn’t change the fundamental truth: a good idea poorly executed loses to a mediocre idea brilliantly executed. And let’s be honest, if you’ve been around in development long enough you’ll know that most ideas aren’t really that good anyway. At least not good enough to spend weeks of time building. With AI we can execute any idea in a matter of days or less.
If you ask me, what we’re seeing is a flood of apps built quickly without much thought put into the actual user experience. AI can help you ship fast, but it can’t tell you whether what you’re shipping is actually good. That still requires human judgment, taste, and care. And more importantly, it requires a target audience.
AI makes iteration cheap
Here’s where things get interesting. If you care about your product, have a target audience, and want to make something that works incredibly well, AI becomes an invaluable tool for exploration.
You’re now able to iterate faster than ever. You can look at more ideas, explore more options, try more possibilities. And you can do all of this in your actual app before you commit. The cost of experimentation has dropped to near zero.
Let me give you a concrete example from Maxine, my fitness app. I recently added a streaks view. Without AI, this would have taken me a day or two to build. With AI, I built it in about 10 minutes. That’s essentially a zero-cost investment to try something new and see how it feels.
Now, I did have to make manual adjustments afterward. The AI got me 80% of the way there, but the last 20% needed human attention. And that’s fine. That’s the point. I ended up with a feature I really like, and it cost me a fraction of the time it would have otherwise. To be perfectly honest, this feature would have been very low on my effort vs. value list even though, once I built it, it started feeling valuable immediately.
I’ve been doing this constantly with Maxine’s UI. Between workout sessions (I work out three times a week), I’ll tweak the interface. One day I’ll try a new layout, get AI to change things, then actually use it during my next workout. If something feels off, I iterate again. This rapid cycle of build-try-refine is only possible because AI has made the building part so cheap.
The code was never the hard part. The code was, in many ways, the boring part. It was the thing we had to do, the part where we spent hours articulating our thoughts and plans into actual implementation. Now AI handles that, and we can focus on what really matters: building great experiences and tweaking the details to fit our goals.
Using your own app is the differentiator
Building fast is great. But when you’re building fast and you’re not using the app you’re building, you’re not seeing what your users see. You’re not living life with your app. Often that leads to a pretty average experience.
AI often won’t really do much more than average. It can generate reasonable code (if you’ve set up good guard rails), it’ll make sensible layouts, decent flows. But it doesn’t know what it feels like to actually use your app in the real world. Only you (and your users) do.
Often when I try a new UI in Maxine, I create something that looks pretty in isolation. It might have gotten some feedback from peers based on images, and then I actually use it during a workout and I realize it’s not quite right. Maybe it’s too bright when I’m tired and sweaty. Maybe a button is too small when I’m rushing between sets. Maybe the information hierarchy makes sense when you’re looking at a screenshot but falls apart when you’re actually in the moment.
Users will tell you this too. They’ll say something is too bright, too big, too small, whatever. And sometimes you can’t quite figure out why until you put yourself in their shoes.
This brings me to a UX principle I learned a long time ago when I was in college. Imagine you’re building an app that helps users check train times. Your user wants to know: can I still make that train, or do I need to catch the next one?
The instinct might be to build an information-dense screen. Show them all their options. Five trains, departure times, platform numbers, transfer information.
But think about who’s using this app. There’s a good chance they’re in a rush. They might literally be running toward the station, phone in hand, trying to figure out where to go. They don’t have time to read five options and compare them.
So instead of giving them everything, give them the one option that’s probably what they need. Reduce steps. Make things obvious. Your app might not end up looking as sophisticated or comprehensive when you’re sitting at your desk designing it. But once you start using it, once you put yourself in your user’s situation, you’ll build something that actually serves them.
If you want your UI to be good for what the app does, you have to use your app. You have to build domain knowledge. Sometimes you’ll build something that doesn’t look right in isolation but works perfectly in context. That’s not a bug. That’s craft.
The human touch vs. vibe-coded slop
My only real argument against shipping fast with AI is this: don’t ship fast for the sake of shipping fast.
AI can help you build slop really quickly. And you don’t want to build AI slop. You want to build something good.
Sure, you might be tempted to chase quick releases for quick money. But that doesn’t make your apps better. It doesn’t build something you’re proud of. It doesn’t create something users will actually love and stick with.
The strongest argument in favor of AI-driven coding, and one I completely agree with, is that it allows us to focus on what really matters. The implementation details were never the interesting part of building software. The interesting part is figuring out what to build and how it should feel.
AI lets us iterate faster than ever. It lets us try things we wouldn’t have bothered trying before because the cost was too high. But the human judgment, the taste, the empathy for your users—that’s still entirely on you.
When you combine fast iteration with genuine care for the product, you get something special. When you combine fast iteration with indifference, you get slop.
Summary
AI is changing development, but not in the way the doomsayers suggest. Yes, there are more apps than ever. But ideas were never the differentiator—execution was, and execution still requires human judgment.
The real opportunity here is that AI makes iteration nearly free. You can try things, use them, refine them, and try again. The developers who will stand out are the ones who actually use their own apps, who put themselves in their users’ shoes, who care enough to polish beyond what AI generates.
Use AI to speed up the boring parts. Use your own judgment for everything else. That human touch is what separates craft from slop.