The Rise of Fast SaaS
And how I "vibe coded" a fully-functional app
Vibe coding lol
Love it or hate it, it’s here. So let’s talk about it.
Y’all may remember a previous article of mine back in 2023 called The Rise of Artisan SaaS. It was an ode to the era of high-craft software that boasted insane attention to detail, opinionated flows and micro-interactions (ie. the Linear trend).
But 2023 was a lifetime ago in “AI years”. You can think of this article as a Part II amidst the ever-changing tides of technology. Not to sound melodramatic, but today in 2025, we’re experience the beginning of a new technological shift, not unlike the invention of the printing press or blogging.
Consumption of ideas: In the 1400s, the Gutenberg press freed people from the monopoly of priests who interpreted scripture for them. Suddenly, there was an explosion of literacy as people had direct access to read, learn and, ultimately, think for themselves.
Distribution of ideas: Fast forward to the 2000s, and the internet did the same for the distribution of ideas. You no longer needed a journalism degree or a newspaper column to share your thoughts with the world. If you had a blog, you had a voice. If you had Twitter, you had an audience.
Realization of ideas: And now, we're entering a new chapter. Thanks to AI coding agents, anyone can take an idea in their head and build software to bring it to life.
Short interlude: No, I don’t believe engineering is dead
I even tried my hand at it back when GPT-4 launched.
But this… this is different. Back then you had to copy and paste all relevant files into ChatGPT to provide context to the LLM, then copy the output back into your code editor and cross your fingers that you wouldn’t run into bugs. And if you did, you had to copy the bug and paste it into ChatGPT etc. etc. etc.
Now, you just type into a chat box and let the LLM do all the work for you with the occasional, “didn’t work, try again”. So of course, I had to take another stab at it. Keep reading to the end to read about my experience “vibe coding” Paddles.ai and what I learned about keeping the AI on track.
But let’s go back to this whole technological shift thing.
Welcome to The Glimpse
Join thousands of leaders from companies like Nike, Google, Uber, Coinbase, Twitter and Venmo as we learn how to build the future.
The Great Debate
Historically, software development was a specialized skill set. If you had an idea, you needed to work with someone who could translate it into code. It was a slow, often expensive process that created a natural gate between those who could dream and those who could build. That’s why so many of the Y-Combinator companies started with two co-founders: a product, design or sales guy and then a technical guy. But always a technical guy.
Now, that dynamic is changing. Tools like Replit, V0, Bolt, Lovable, Windsurf, and Cursor are making it possible to speak in natural language and get working code in return. You describe what you want, and the AI does its best to make it happen.
It’s a powerful shift, especially for folks like me - designers who have just enough technical chops to be dangerous. Now, we can move from an idea to a prototype in the span of a day, without waiting on engineering bandwidth or learning a full-stack engineering. The keyword in that sentence being “prototype”.
This new unlock introduces new complexity. It lowers the floor to write working code, but doesn’t necessarily raise the ceiling. As a result, many of the apps that are yeeted out over a weekend are fragile and vulnerable.
And boy are the people taking sides!
“Vibe coding will never be more than a party trick”
“Engineering is dead - long live vibe coding”
“This LLM code is dog water!”
“I just vibe coded this app last week and made $69K”
Fast SaaS vs. Artisan SaaS
And it’s these sorts of “hot takes” that make me roll my eyes because the truth, per usual, is somewhere in the middle.
I think we can get a good grid of where the future is headed by framing it up against fast fashion. Trends come into vogue and are gone the next season. As a result, the clothing manufacturing pipeline adapted, optimizing for cost and speed knowing their garments would just end up in a landfill in 9 months.
But fast fashion didn’t kill quality brands - it just filled a different need. I have a Cahartt coat that my dad passed down to me. Believe me, he’s put that thing through the wringer over the years and it’s still a great coat! The world still needs high-craft clothing.
In the same way that fast fashion emerged from a drop in the cost and complexity of creation, so has Fast SaaS. The upside is undeniable: more people building, more ideas tested, more needs met. But just like fast fashion fills landfills with barely-worn garments, Fast SaaS will leave behind its own trail of abandoned prototypes, broken tools, and single-use apps forgotten on a server somewhere.
And that’s where high-craft software stands apart. It’s not about being slow or precious - you can still use AI to assist you and move quickly. It’s about being intentional and building for resilience. Like the old Carhartt coat my dad handed down to me.
Fast SaaS will continue to rise, and I genuinely believe that’s a good thing. But so will our appetite for tools we can rely on. The divide will just grow more stark.
The future isn’t either-or. It’s both-and.
That’s the end of my philosophizing about vibe coding but if you’re still here and want to read about my experience building an app with AI that’s more than just a prototype, keep reading. It can be done!
I’ve included the tips and tricks that I’ve learned the hard way to minimize problems and maximize quality output - hope it helps.
My Vibe Coding Experiment
Before I ever thought about building an app, I was logging my casual pickleball matches in Apple Notes. I wasn’t playing competitively, but I still wanted to know some stats just for fun like my win/loss ratio, win streaks, who I played best with in doubles etc.
Every so often, I’d copy my notes into ChatGPT and ask it to generate some stats for me. It was janky knowing what I know now, but it worked!
The more I thought about it, the more I realized there’s a slice of the Pickleball community like me that might enjoy these sorts of stats too. They’re not serious pros, but they’re not casual players either. I’ve been calling them the “casually serious” for lack of a better term. So I decided to put these AI tools to the test and scratch my own itch.
Today, there are a handful of tools out there like Lovable, Bolt, and V0, but I started working on this toward the end of 2024 and they hadn’t hit their hype-cycle just yet. Despite that, even today, I’d choose Replit for two key reasons:
Code transparency: Replit let me inspect and modify the code directly. If the agent generated something weird, I could go make edits myself.
Unified stack: Replit bundled everything I needed - database, secrets management, hosting, and deployment - into one product. For simplicity, I didn’t want to have to piece together multiple tools like Supabase and Vercel just to get something deployed.
Here’s a good comparison chart from Lenny’s Newsletter that shows what each tool supports.
Start with your stack
What followed was a lot of trial and error. I restarted the project four or five times before finding a rhythm. Replit didn’t respond well to massive prompts outlining all the functionality I wanted. So instead, I broke the process into smaller steps. I asked it to scaffold a basic app with TypeScript and Tailwind since I'm familiar with these frameworks and could step in as needed.
Update: On March 28th, Replit released Agent V2 that came with some seriously good buffs so my method of starting small with the original prompt may not be as necessary any more.
Dial in your database
I quickly realized that jumping into features too early created chaos. The database became tangled and incoherent, mostly because it was forced to make database changes on the fly for each feature (this is where a bit of technical knowledge came in handy, but hopefully you can learn from my mistakes). So I paused and built a list of all the features I wanted. Then I asked the AI to reason through the best architecture for those features. Once I had a schema I liked, I started a fresh thread, gave it the schema, and asked it to implement it cleanly.
This had a huge impact because it focused the task to just setting up the database which allows any features built later to not have to worry about that step.
Focus on your features
From there, I iterated on features one at a time, using a two-step prompting process:
First, give it a full description of the feature you want to build and ask it to come up with the best plan to implement it given the architecture. It’s important to also remind it to not write any code at this step. If you don’t explicitly say that, it will sometimes come up with a plan and then immediately start implementing it.
Next, start a brand new thread to actually build the feature. The reason is that when it was reasoning through the plan in the previous step, it added a ton of files to its context window which means you’ll hit the limit of what you can accomplish in that thread super quickly. Now, with a clean context window, you can just paste in the plan that it gave you and it usually can one-shot it pretty well. If the plan is more complex (5+ steps), I broke it into smaller chunks and pasted each chunk into a new thread.
Clean up your code
Every few features, I asked the AI to run a cleanup pass - consolidate logic, remove unused code, clean up any logging used for testing, and rewrite comments for clarity. With each new feature, the AI would occasionally leave behind outdated code or comments which confused future prompts so this just cleaned it up so it wouldn't get confused in future passes.
Babysit your bugs
Now let’s talk about bugs. Most bugs don’t happen in the feature that being implemented. The LLM actually does a pretty solid job of writing the code from the plan you gave it. Most bugs come from these weird little tangents the Agent gets on where it deletes or edits code that has nothing to do with the task at hand lol so annoying.
The best way to avoid these types of bugs is to catch them as they’re being written (aka, babysitting the AI). I keep an eye on which files it’s editing in real-time, and if it starts making changes to files that aren’t relevant to the current feature, I immediately pause it, ask it to revert the changes, and remind it to stay focused on the task at hand. That usually works. Worst case scenario, I look at the change log and revert the changes manually myself if it’s having trouble.
Since December, I've been shipping a feature or two each week and, because Replit handles hosting and deployment for me, I can push updates immediately without worrying about devops stuff. I know I just talked a lot about how to minimize AI screwups, but it’s honestly wild that it’s this easy. I’ve had so much fun with it and at the end of the day, shipped something that’s super useful to me and others.
What Comes Next
We're entering an era where anyone can build software.
But not everyone will build great software.
I’m anticipating a flood of weekend projects that are half-baked and never maintained. And that’s not necessarily a bad thing. Sometimes, utility has a short half-life.
But amidst that flood, there will be a renewed appreciation for software that lasts. For the digital Carhartt coats. For apps that reflect the care of their creators.
Artisan SaaS isn’t just about aesthetic design anymore. It’s about architecture. Durability. Security. Performance. It’s about software that’s not just written, but crafted.
That’s the future we’re building.
—Jacob ✌️
❤️ Smash that heart!
If you enjoyed this article, smash that heart icon to show some love and don’t forget to share it with a friend!