We Let Lovable Build an App Almost Entirely on Its Own... Here's What Happened
How vibe coding took an AI-native collaboration platform nearly to the finish line and what it means for the future of software.

How far can AI actually go if you hand it a real problem and get out of the way? We decided to find out and set a rule going in: no engineering help unless it was truly unavoidable.
Moustafa, our CEO and co-founder, wondered if the team could communicate more effectively with a tool other than the popular ones on the market, where conversations lost context, nothing signaled what actually needed attention, and the "smart" features bolted onto most chat tools felt like an afterthought rather than the core experience.
Instead of writing a feature request or waiting on a roadmap, he set out to test whether he could build a better tool himself, using nothing but natural-language prompts.
"We wanted to rethink how a work communication tool should feel in a world where AI is a full-fledged member, not just a plugin."
Moustafa, co-founder of Blink22
What followed was a 72-hour experiment that tested a question we think a lot about at Blink22: how much of the traditional software development process can agentic tools actually replace on their own, and at what point does human expertise become unavoidable?
Serene Chat: An AI-Native Collaboration Platform
The vision wasn't complicated to articulate, but it had never quite existed off the shelf: a messaging and collaboration tool where AI isn't a chatbot in the corner but the connective tissue of the entire experience.
Every feature was designed around one goal: reducing cognitive load and surfacing what actually matters. That meant discussions with a clear status instead of endless open threads, urgency that's visible at a glance instead of buried in unread counts, and an AI layer woven into search, summaries, and responses instead of tacked on as an extra button.
Product Features
The idea behind Serene Chat was simple: your communication tool should help you close loops, not open more of them. Here's what made it into v1:
Discussion Status Tracking Conversations in channels can be marked as open, on hold, or resolved. Discussions aren't just chats; they're units of work with a beginning, middle, and end.
Action Dashboard A full-screen view of everything still pending across every channel, without opening a single thread.
Urgency Prioritization Conversations can be flagged as important, urgent, or open, so teams can focus on what matters most without losing track of everything else.
Channel Overview A single panel per channel showing recent activity, open discussions, urgency, and outstanding action items.
AI-Suggested Responses The platform reads the context of a discussion and suggests relevant replies. Less thinking, faster unblocking.
Conversational Search Ask the app something like "What are the latest updates on the marketing project?" and get a structured summary instead of a list of timestamps.
Task Log + Calendar Tasks live on a visual, drag-and-drop calendar with automatic deadline tracking. No separate project management app required.
The Process: 48 Hours Alone, Then a Developer Stepped In
The build happened through Lovable, an AI-powered development platform that translates natural-language prompts into production-ready React code.
For the first 48 hours, Moustafa didn't write a single component from scratch and didn't bring in engineering support. He described what he wanted, reviewed what appeared, and iterated entirely on his own.
Hours 0 to 24: Conversations and Core Architecture
Channels, discussions, message threads, and the status system (open, on hold, resolved) were established by describing user flows in plain language. No developer involved.
Hours 24 to 48: Intelligence Layer and Prioritization
Suggested responses, conversational search, channel summaries, and urgency flagging came next, along with the action dashboard and the task log with its drag-and-drop calendar. Still solo, still just Moustafa and Lovable.
Hour 48: A Developer Joins
This is where the experiment hit its limit. A supporting developer was brought in specifically for the pieces Lovable couldn't handle reliably on its own: workspace management, invitation flows, and real-time performance. Design iteration through prompts and reference templates continued in parallel.
Hours 48 to 72: Finishing the Build
With a developer now handling the infrastructure layer, the remaining 24 hours combined AI-driven iteration with targeted human engineering to get the product into a working state.
The Numbers
The most common argument against building custom software is cost, measured in time, people, and runway. This experiment put a hard number on what agentic development changes and where it stops being enough on its own.
This experiment | Traditional process | |
Build time to finish V1 | 3 days | ~4 months |
Work completed by AI alone | 90%, in the first 48 hours | 10% |
Developer involvement | 1 developer, brought in at hour 48, for specific infrastructure only | 2 to 3 developers, for the whole project |
Two full days of a working, AI-native product with zero engineering input is the headline number here. The remaining 10% is what took a developer to close.
Our Honest Take
Getting 90% of the way to a working product in 48 hours with no engineering input is a genuinely different pace than software has ever moved at. It's also not the whole story, since that last stretch needed a human to finish.
Benefits
A founder can build the exact product they need, not a compromise shaped by available engineering hours
Iteration is conversational and near-instant; a feature change is a sentence, not a sprint
Design can be adjusted by describing or uploading a reference; no design system required
Niche features that would never justify a development ticket can simply exist
The AI can debug, explain, and improve the codebase mid-conversation
Two days got further than most teams get in weeks, with zero engineering involvement
Limitations
There's a real ceiling: at hour 48, further solo progress stalled without a developer
Complex infrastructure, like workspace management and invitation flows, was beyond what the AI could handle reliably
Security vulnerabilities emerged, including data exposure issues that needed a trained eye to catch
Scaling without human optimization degraded performance
AI-generated code can accumulate technical debt if it isn't reviewed
Edge cases and error handling often needed manual attention
Some bugs required continuous prompting rather than a clean, targeted fix
Why Real Developers Still Matter, A Lot
Nothing about this experiment suggests software engineers are becoming redundant. If anything, it pinpointed exactly where their expertise became irreplaceable, almost to the hour.
Performance and Scalability: AI-generated code optimizes for correctness and coherence, not production load. As feature complexity grew, performance issues emerged that required a developer to diagnose and fix at the infrastructure level.
Security: One of the more concerning issues found was private messages surfacing where they shouldn't have. That's not a quirk; it's a breach. Fixing it required a developer who understood the full threat model, not just what the feature was supposed to do. You can't vibe-code data access controls, authentication flows, and permission architecture into existence.
Complex Features: Workspace management and invitation flows, the infrastructure that makes a team collaboration tool actually function, were beyond what Lovable could handle reliably. That's precisely why a developer was brought in at the 48-hour mark, and not sooner.
Maintenance and Evolution: Anything built this way still needs to be understood, refactored, tested, and documented by people who can reason about a codebase beyond prompt and response, especially once it's meant to hold up under real use.
The 10% that required a developer wasn't the easy 10%. It was the part that determines whether a product is trustworthy, stable, and able to scale. That's still a human's job.
What We Took Away From It
This wasn't about shipping a product. It was about finding the line: how far can one person get with AI alone, and how fast does the traditional 4-month, multi-developer timeline collapse when agentic tools take the first pass?
The answer, at least in this case, was 48 hours of solo progress covering 90% of the build, followed by 24 hours of a single developer closing the gap on the 10% that actually required engineering judgment. Compressing that against a ~4-month traditional timeline with 2 to 3 developers is the real headline.
That's what agentic development actually is: not a replacement for engineering, but a new starting point, one that changes how much distance a single person can cover before a developer needs to be in the room. It's a shift we're building our own process around at Blink22, and one we now understand well enough to apply for clients too.
Blog
Our Clutch Standing in 2026A 4.9 rating, Clutch 1000 honors, and #1 rankings in Dubai and Qatar.
Choosing an App Partner in DubaiWhat Chamber-recognized startups look for in an app development company.
Agentic Development vs. Vibe CodingThe real difference, and which approach your project actually needs.
Let’s Build Together
Tell us what you’re building. One of our experts will be in touch within 2 business days to talk through scope, timeline, and the right team.