I Tried Building a Real App with AI. It Took a Year
alexhyett.com
alexhyett.com
Before AI dev was expensive so I'd spend hours planning features. I filled 5 notebooks with UI sketches and data schemas and lists of names of what to call things. Building was more or less final as I only had 5-10 hrs a week max and wanted to move on.
Now I type directly into the Claude Code chat box and it writes it in front of me. I haven't planned a thing in months. As a result the app swings wildly around based on my whims and feelings. I can rewrite the whole thing based on something I thought of in the shower. Then days later I realize it isn't right and I rebuild it again. All of the rewrites have done a number on the code and I see dead patterns everywhere from stuff long since deleted.
In a professional app I'd have others to hold me accountable so it's not exactly the same but AI has made it very easy to make a lot of bad apps quickly. If you know exactly what you want though it can feel like magic.
I just hope it's still respecting the data loading and caching algorithms I designed so carefully cause I wouldn't know if it wasn't anymore.
Is it bad from a user or performance perspective, or just untidy and unaesthetic from a developer’s perspective? Because the developer’s perspective is becoming increasingly unimportant as LLMs become the main readers and writers of the code.
Aesthetic code is clear & consistent and therefore more readable. Supposedly we’re all awesome at PR review and use an aggressive process of manual review now, so readability should be a priority.
LLMs have context windows and compress them arbitrarily, inconsistent or messy areas of code can be read and improperly weighted in any given session, code base cleanliness gives consistency of generation.
… LLMs or not, I simply can’t imagine making a large(r) pile of crap for myself to maintain & customers to use in their businesses is some grand engineering benefit over time. If those agents are so great make ‘em do the entire job and refactor tested utility into a digestible & defensible product.
Until the LLM itself becomes confused by the 10 layers of old patterns that weren't fully deleted from the code base, 5 of which do more or less the same thing but in minutely different ways that cause issues.
Users really like stability of their experience. They want the things that are working to keep working. If something is bit weird but acceptable they expect it to continue like that. Going back and forth between things might be the worst. After bad bugs like data being lost or thing not working at all.
But, thanks to the magic of keeping track of time and tasks, I have discovered:
- I am not all that faster when project timelines are concerned
- I've often built things with AI with the latest and greatest technologies that I've always wanted to learn but never did, like write a microservice backend with the trendiest frameworks with infrastructure as code and all the bells and whistles, while previously I was content with a server executable sitting on disk (maybe in a container), writing to a sqlite db file next to it.
- The new tech has serious performance DX/UX and cost issues. While previously deployment was just a copy, now I have to wait for terraform to churn through the monstrosity I made with AI. Debugging is hard.
- There's no prestige in building with fancy tech. AI can build using microservice orchestration. It can build using a simple CRUD blob as well. You just have to ask it. A lot of appeal of said fancy tech lay in prestige, newness, and exclusivity, and it sucks in very tangible ways.
- I used to be much more awesome than I gave myself credit for. Looking back at my old code, the amount of highly dense and quality code I cranked out during my productive periods was way more than I though, and you could feel it was thought through. Rather than doing the feature sloppily then fixing the 5 corner cases, like AI does, I carefully considered execution flow and made sure the simple looking code actually did everything correctly. This meant that it had a ton of missing mental context that I couldn't replicate just by looking at it after a long while, and touching the code without rebuilding it was a futile exercise.
- I fooled myself into thinking I understood what AI was doing, but in reality, I was far less aware than I expected and needed to be
That is what I love about coding. Not just insofar as it's necessary and useful (it is both), but just as a puzzle in its own right, to a fault. It's just a type of "imagination" that I don't really apply often otherwise, since e.g. I'm not into math, not an organizer or manager etc. Though I did have jobs where I instantly saw ways to optimise some things I do credit to having practised with code. You just try to think through what will happen given the known landscape and the given decided plan, what could happen given the known unknowns, how your heuristics would deal with that, and unless it's all green you see if you can change the landscape, the plan, explore some unknowns, and/or improve your heuristics (by which I just mean what you use to make ad-hoc decisions when things don't go according to plan). That kind of becomes a habit which can get applied to and improve lots of things. Measure twice, cut once, so I don't have to spend three days because of a stray comma (again).
Amazing how many software engineers don't do this and continue to fool themselves into thinking they're faster with AI. If only more people would track and reflect on their time use.
Developers and companies who put real care into their product will come out on top. A large part of that is going to be, what not to build - something AI agents will always say yes to.
To be fair, was always the case but its only going to be made more apparent as AI scales out.
Is it typically bug hunting on edge cases? Feature requests? If the initial product is polished enough, what can I realistically expect to run into down the line?
Now, I can't promise it's advice is worth taking, but they do seem to be taking strides at judging the relevancy of some needless additions.
We can definitely mould AI agents to think more critically about these things, I dont know how effective it will be in the long term honestly.
Excellent case for open source local software.
This right here!
I have very little issue with LLM-generated code, my issue is mostly with people throwing codebases over the fence, declaring it the best library/framework/app/platform/whatever and in 3 months I know the repo will say "Last commit 3 months ago".
Some things are "done" and don't need constant updates but most of the "bad" LLM code IMHO is the kind of stuff I know requires dedication (even if an LLM is writing all the code) and commitment to the library/etc for it to succeed.
If all you've done is vibe-coded something and aren't going to support it then I'll just vibe-code my own version tailor-made for my use-case that I can support myself.
I've thought about this a lot in relation to my side-business "could someone vibe code this?" and the answer is absolutely yes they could, but my customers don't come from me throwing code out into the world and walking away. My continued support, handling issues, being on-site for events (I make event-based software like food festivals) is where I provide the value. They've never once cared what the code looks like or how it works, it's the support they are really paying for. Someone to have the answers and track them down if they don't have the answer at their fingertips, that's the value I provide (and always have if I'm being honest).
Follow-through continues to be best way to achieve success IMHO.
In my opinion, the basics of software engineering haven't changed, it's just faster to write the code.
e.g. the below plan is just applicable for humans or LLMs when building systems that are sensitive to small changes/errors and have catastrophic failure modes. (e.g. trading, avionics, health etc)
1. Have a very detailed plan of how you want it to work
2. Break the work into components
3. Work on each component and test the component extensively
4. Once that component is good, move on to the next component
5. Tie all those components together and confirm they work via integration tests etc
There is a STRONG temptation to just tell the LLM "Build me a system" but that is a bad idea and was also a bad idea with humans.
Sure, LLMs speed up #2 and possibly #3. For #3 specifically, almost all of the top developers I know are using LLMs to write the code but are writing the tests by hand or spending most of the time reviewing the test code written by LLMs. I would argue that this is how it should be.
I've given up trusting lifetime anything from the app stores now.
Mobile OSs seem to evolve so much faster, add new layers of security, lock pro features behind app store billing APIs that require the developer's account remains in good standing.
I've been burnt by three apps cutting and running now. One where the developers got their prize jobs at Microsoft and AWS [1], another where they sold the app off to another company that gave up maintaining it [2] and finally EA (enough said) [3]
[1]: https://news.ycombinator.com/item?id=46768909
[2]: https://www.androidpolice.com/2018/04/16/beyondpods-first-pu...
[3]: https://web.archive.org/web/20190116224256/https://answers.e...
Last September they declared that the app was "too valuable to give away for free" and told me I had to subscribe to use it. Even though it hadn't been free, I'd paid for it, and nothing about it had changed in the decade since I paid for it. Everything else was already locked behind a subscription I didn't find value in.
Seems like a lot of companies these days think "lifetime" means "until we really really want more money"
I went through a previous thought experiment about what would happen when we moved a paid up front feature behind a subscription. This was the outcome I came to. Unless the user bought and installed a physical app, on the desktop, outside of an app store, they were going to get the rug pulled out from under them.
I've always thought of cloning the old Zero fasting app into one, when I have a bit more time to point my Claude at building something else.
Also, the more and more every {expletive deleted} app thinks that the simple features are worth a $14.99/month subscription, the more sense going to open source makes. Yeah, it can be a bit annoying. But "a bit annoying" starts winning out over "a cumulative $200/month set of subscriptions" eventually.
The 6 months of cleanup is something a true no-code vibe coder would have never done. I also think that kind of person might be inclined to keep AI going down the simplest development lane possible, which probably means using a more web-native technology rather than a native app that relies on an IDE the AI can’t work well with.
Something like Expo, for example.
I found that the most time consuming part of iOS app development in a vibe coder scenario was the various “red tape” of the process for the App Store including submission.
Using LLM tools can greatly accelerate development when used effectively, it can enable much smaller high performing teams to be much more effective. But it's not magic and if you're holding it wrong it really can be a hindrance rather than a benefit.
The easiest way to do that would be to clone the repo for the open source Loop habit tracker: https://github.com/iSoron/uhabits and then ask Claude Code to study the data model and API, and help me think through what I need to add/change to support the features I want.
Once the data model is in great shape, then let the AI go and build, test, iterate etc.
I think the hardest part was actually automating the release pipeline to directly upload to the App Store for a release with Test Flight.
It wouldn't have been possible without Claude's help.
Then next hard and tedious part was do a complete conversion to Android with Kotlin, which I also didn't have any experience either. That one-to-one parity was rather painful but it was done in about a month or so.
Now I just develop create features on the iOS version first and then do a parity match with the Android version after with Claude.
I haven't really done any iOS-native programming in about a decade, but I have spent a godless number of days working through bugs, inconsistent behaviors, poor documentation, and weirdly broken builds in Xcode and iOS and various SDKs, and then going through a different version of the same hell for every new release.
Like, after suffering through the first few upgrade cycles, I started keeping a journal of repeated issues that came up, hoping I could reference it and save me some headache the next time... and then the journal just kept growing!! Every goddamn new release had a bunch of new headaches to deal with.
I recently touched upon some iOS/MacOS-related development (Safari extensions), hoping things had improved over the years, and immediately ran into frustrating dev experiences. Unfortunately I'll be doing more of this. TFA was light on the details, but it still left me with a bit of a 1000 yard stare.
Additionally, the ai models only got good in November/December last year. How easily we forget.
The result of this? I had to do several full rewrites and there are still many bugs left over from these. AI simply wasn't powerful enough to do the task and littered the codebase with issues that I'm still even now dealing with.
So far I never built anything that didn't need human in the loop, otherwise things just don't function well or my ideas are not translated as well.
I didn't find app building to take that long, even without knowing the ins and outs of kotlin and swift.
I did find the process of publishing the app to be one of the hardest things. The last 10 - 20 percent of app development still requires a lot of paperwork of you aren't already a developer.
> I started with a simple hello world application. Then added in the habit list, the ability to add a habit, edit a habit and so on.
This hands-on, incremental approach works, of course. But I don't think it is the most effective way of using LLMs to write apps.
1. Which apps should be built like this?
2. Which apps shouldn't be built like this?
My instinct is that any app worth building and using for a long time should be built incrementally. Otherwise, slop.
Instead, I've settled on a top-down approach: I write an in-depth spec for the whole app first, then have the LLM implement reviewable sections of it.
to me the key point is that I get those better ideas a lot more readily by looking at the code than by planning up front - I have a good feel for when adding the next feature is harder than it should be, or when the resulting code is messier than I would like, and seeing the concrete code usually gives me the best idea for how exactly to improve it.
The details are important. You shape the details, and the details shape you in turn as well.
Pretty much every job I've had since 2003 involved cleaning up human-written slop.
For the moment, I'm finding that AI speeds up certain things: It can bang out unit tests in a few minutes, or do 80% of the work for me; but once it gets to the "test, make small change, test" loop, that's all done by hand.
Is there really much use in deconstructing a vibe coding process that was used before the term "vibe coding" existed? It's like critiquing a caveman's fire-starting routine.
> Meanwhile, the senior developers are in 2 camps. One half are using AI for absolutely everything but are slowly losing their ability to code. The other half are so sick of AI and are getting burnt out having to write prompts every day that they just don't want to do it anymore.
Again, this sounds like what developers were saying about AI a year ago. The refrain from the development world hasn't sounded like that for a while.
EDIT: Okay, Andrej tweeted about Vibe Coding on February 3rd 2025, and Claude Code was released in the same month. But Cursor was already there (I can see usage starting January 2025 in my account and know that it took me a few weeks before I tried it).
https://simonwillison.net/2023/Dec/31/ai-in-2023/
Here it's called "Vibes Based Development"
Now I have 20 YOE in software too before the booon of AI.
The hard part were actually the sales but I'm getting quite some, going physically(!) to places.
Hosting costs $50, revenue is ~1k/month, nothing special but its basically on autopilot.
I did have the app for 6 months for free on a first client where they would give me feedback bugs etc until i felt it was stable.
I don't even have a pricing page, i try to see how much i get can from each client, from $5/mo to $100/mo
That seems ethical. Vibes based fees.
Every feature cost me the same (tending to $0), but i price them as i see fit.
There is so much confusion around "the AI bubble". I am sure a lot of things will deflate, fail, people will go out of business, model development might slow, people might lose money on hopeful 1000x investments – but not because from here on out we suddenly notice that AI capability was all just illusionary and we will not want it anymore.
In terms of capabilities, at the very least, what we now have will be here, forever. LLMs will be here, and they will be used, until something better comes along.
The problem lies in convincing other people to use it. So far I am the only user.
And, this is not a new experience. I have a utility to change the gamma ramp in a GPU, for windows, that still works in Windows 98, XP, 10, and 11, even Linux and X Window with Wine, and so far I am the only user.
I wrote it because I had an old CRT that was too dark and unusable with the default gamma.
So now everyone can do these one-user apps. Welcome to my world :)
Ergo: I'd always go for "NO A.I. WAS USED IN CREATING THIS PROGRAM"
Companies chasing pipe-dreams of getting rid of all those developers will go bust in a couple of years. At the very least their brand image will be tarnished.