I’m a software engineer.
I’ve spent years building production applications, designing architectures, integrating APIs, setting up cloud infrastructure, debugging deployments, dealing with databases, authentication, CI/CD, performance problems, and all the other things that come with turning an idea into actual software.
So I’m usually pretty difficult to impress with an AI app builder.
I’ve seen the demos.
Type a sentence.
Get a pretty landing page.
Everyone claps.
Then you open the code and discover that you still have a long weekend ahead of you.
Lovable surprised me because it started feeling less like “an AI website generator” and more like a rapidly evolving software-development environment.
And yes — my own portfolio, amitchakraborty.dev, was built with Lovable.
That experience genuinely made me stop and think:
What exactly is a web-development stack going to look like in a few years?
The interesting part isn't “AI can write code”
We already know that.
Claude can write code.
GPT can write code.
Cursor can write code.
Codex can write code.
The interesting shift is happening somewhere else.
The distance between:
idea → architecture → implementation → backend → deployment → iteration
is collapsing.
A few years ago, even a relatively simple production application involved stitching together a long list of services:
Frontend.
Backend.
Database.
Authentication.
Hosting.
Storage.
Email.
Payments.
Analytics.
Monitoring.
AI APIs.
CI/CD.
DNS.
Domains.
Secrets.
And then you still needed to connect everything.
Today, platforms like Lovable are trying to compress much of that workflow into a single development environment.
Lovable describes itself as an AI software engineer for building web applications, and its current platform goes significantly beyond static pages. Its ecosystem includes Cloud, integrations, analytics, authentication, payments, AI features, security and agent integrations.
That is a much bigger idea than “AI makes websites.”
Then I discovered what was happening under the hood
This is the part that caught my attention as an engineer.
New Lovable projects now use TanStack Start as their underlying framework.
That means the generated applications are not simply traditional client-rendered React/Vite applications.
Lovable moved its new projects toward a full-stack React architecture supporting SSR, SSG and CSR, with server functions and Cloudflare Workers underneath, while continuing to use Supabase for database, authentication, storage and realtime functionality.
That matters.
Because there is a big difference between:
“Generate me a frontend.”
and:
“Generate me a real full-stack application with server-side execution, routing, data access, authentication and deployment.”
For developers, that changes the conversation.
You're no longer just asking:
“Can AI write React?”
You're asking:
“How much of the software lifecycle can an AI-native development system actually own?”
And then there are AI-native applications
This is where things get even more interesting.
Lovable isn't only using AI to help developers build applications.
It is increasingly making the applications themselves AI-capable.
Lovable's platform supports AI functionality inside applications, and its current billing model treats building, Cloud hosting and AI features as part of the same credit system. The free plan currently includes daily build credits, Cloud credits and a small allowance for AI features.
So the architecture starts to look like:
Human → AI development agent → application → AI features → users
rather than:
Human → IDE → code → application
That distinction is going to matter a lot.
MCP changes the game again
One of the most interesting recent additions is MCP support.
Lovable now allows published applications to expose an MCP server so compatible AI tools can interact with the application directly. Lovable says this allows users to work with their apps from tools such as ChatGPT and Claude, using the permissions and actions exposed by the application.
Think about that for a second.
Normally:
User → opens your website → clicks buttons → performs actions
With an MCP-enabled application:
User → asks an AI assistant → assistant calls your application → application performs the action
Your application effectively becomes part of the AI agent's toolset.
That means we may be moving toward a world where software isn't always something humans open.
Sometimes software is something an AI uses on our behalf.
That is a much bigger shift than another “AI website builder.”
Lovable is also becoming a development agent, not just a generator
This is another area where I think people underestimate what is happening.
Lovable has been adding more agent-oriented workflows and integrations.
Its MCP tooling allows compatible AI assistants to create projects, inspect project files, send build requests, check analytics and continue iterating on applications.
Lovable is also openly building infrastructure around agents and sub-agents that can delegate work, maintain context and continue tasks across deployments.
So the workflow is slowly becoming:
Describe → plan → build → inspect → test → refine → deploy → monitor → continue
without necessarily leaving the same environment.
For a developer, that's extremely powerful.
And yes… the economics made me stare at the screen
This is probably the most ridiculous part.
The traditional way of building even a small production application often means paying for several different things:
Domain.
Hosting.
Database.
Authentication.
Storage.
Email.
Monitoring.
AI APIs.
Deployment infrastructure.
Developer tools.
Then you spend your time wiring all of them together.
Lovable is trying to collapse a surprising amount of that stack into one ecosystem.
Its current public pricing starts at $0, with a Free tier including daily build credits and Cloud credits. Pro is currently listed at $25/month, with custom domains and additional capacity. Lovable also describes a model where Cloud hosting and AI features consume credits from the same balance.
I personally encountered a promotional/introductory offer that made the economics look almost absurdly cheap for getting a real project online.
And that was the moment I started comparing it mentally with the stack I've traditionally paid for.
I won't pretend the entire internet infrastructure suddenly costs one dollar.
It doesn't.
Custom domains, traffic, transaction fees, third-party services and higher usage can all introduce additional costs. Lovable's own documentation also makes clear that larger applications and heavier usage can consume additional credits.
But the entry barrier is collapsing.
That is what I find fascinating.
What happened to the traditional hosting stack?
This is where my brain started going in another direction.
For years, the normal mental model was:
Buy a domain.
Rent a server.
Configure the backend.
Set up a database.
Configure authentication.
Deploy the frontend.
Set environment variables.
Configure DNS.
Configure SSL.
Add monitoring.
Add analytics.
Add email.
Connect APIs.
Then start building the actual product.
Now?
You can describe a product.
AI generates the application.
The infrastructure is provisioned.
You connect your domain.
Your application is live.
You continue iterating through conversation.
That doesn't eliminate engineering.
But it changes where engineering effort is spent.
And that is the important distinction
I don't think Lovable means developers are becoming obsolete.
Quite the opposite.
I think developers are becoming more leveraged.
The valuable skill is shifting from:
“Can you write this component?”
to:
“Do you understand what this system actually needs?”
Architecture becomes more important.
System boundaries become more important.
Data models become more important.
Security becomes more important.
Performance becomes more important.
Testing becomes more important.
Observability becomes more important.
Understanding trade-offs becomes more important.
And critically:
reviewing what the AI produced becomes a real engineering skill.
Because an AI-generated system can be syntactically correct and architecturally wrong.
It can look beautiful and still have terrible accessibility.
It can work in development and fail in production.
It can generate authentication that looks reasonable but exposes data incorrectly.
It can produce a convincing AI workflow that fails on edge cases.
That's why I still believe experienced engineers matter.
What impressed me most wasn't actually the code
It was the iteration loop.
As a developer, I spend an enormous amount of time moving between tools.
Editor.
Browser.
DevTools.
Terminal.
GitHub.
Database dashboard.
Cloud dashboard.
Logs.
API client.
Documentation.
AI assistant.
Back again.
Lovable compresses a surprising amount of that feedback loop.
You can describe the problem.
See the application.
Inspect the result.
Modify it.
Deploy it.
Then continue.
That reduction in context switching has enormous value.
And it is something that is difficult to quantify with a simple “AI writes X lines of code” metric.
Design has become interesting too
Another thing I've noticed personally is the improvement in design understanding.
A lot of AI-generated interfaces still look like AI-generated interfaces.
Same layouts.
Same gradients.
Same dashboard cards.
Same huge headline.
Same generic buttons.
Lovable has gotten considerably better at taking a visual direction and iterating on it rather than simply producing a one-shot template.
For me, the interesting question isn't whether Lovable can make a pretty screen.
It obviously can.
The more interesting question is:
Can it understand the product enough to keep the design coherent while the product itself evolves?
That is where these systems are becoming much more interesting.
There is another feature I really like: code ownership
This is important for developers.
Lovable's current pricing documentation explicitly says that users own the code and projects they create, subject to third-party rights in underlying AI models. It also supports GitHub integration and continued development outside the builder.
That matters because there is a huge difference between:
“The platform generated something for me.”
and:
“The platform helped me create software that I actually own and can continue engineering.”
The second model is much more compelling to me.
So… is Lovable better than Claude, Cursor, or traditional development?
I don't think that's the right question.
They're different tools with overlapping capabilities.
Claude is extraordinarily powerful for reasoning and coding.
Cursor is deeply integrated into the developer's codebase and editor workflow.
Traditional development still gives you maximum control.
Lovable's speciality is different:
reducing the distance from product idea to working full-stack application.
That is where I think it is particularly compelling.
For somebody who wants to validate an idea quickly, build an MVP, launch a startup, create a client product, prototype an internal tool, create a portfolio, or experiment with an AI-native workflow, that compression is incredibly valuable.
And then something else clicked for me
We're not only watching the cost of software development fall.
We're watching the cost of trying ideas fall.
That's potentially much more important.
Imagine an entrepreneur with an idea but no engineering team.
Historically, the first problem was:
“I need developers.”
Now the first problem can become:
“Can I describe the product clearly enough?”
That's a fundamental shift.
And for developers, it means we get to move faster too.
I can spend less time writing repetitive scaffolding and more time thinking about the actual product.
I can prototype ideas I previously wouldn't have bothered building.
I can test architectural assumptions earlier.
I can throw away experiments without feeling like I just burned three weeks.
That is incredibly liberating.
But there is a trap
The easier software becomes to generate, the easier it becomes to generate bad software.
This is the part I think the industry needs to take seriously.
When code becomes cheap, engineering judgment becomes more valuable, not less.
If ten thousand people can generate an application in an afternoon, the competitive advantage isn't having an application.
It's having one that:
- actually solves the right problem,
- has a sensible architecture,
- handles failure correctly,
- protects user data,
- performs well,
- can evolve,
- can be maintained,
- and gives users a reason to return.
AI makes creation cheap.
It doesn't automatically make decisions good.
Where this is heading
I think we're moving toward a world where the traditional boundaries between:
developer tools
cloud infrastructure
AI assistants
backend platforms
application builders
and AI agents
will become increasingly blurry.
Lovable is already moving in that direction.
TanStack Start as the application foundation.
Cloud infrastructure underneath it.
AI-assisted development on top.
MCP connecting applications to AI assistants.
Connectors bringing external systems and context into applications.
Agents that can continue working across the lifecycle.
That is not just “vibe coding.”
That's the beginning of something closer to an AI-native software stack.
And yes, I built my portfolio with it
So after all the theory, here's the simplest proof I can give:
I used it.
I built my portfolio with Lovable.
Not a screenshot.
Not a generated mockup.
An actual website.
And as someone who has spent years building software the traditional way, I genuinely enjoyed the experience.
That doesn't mean I'm abandoning my IDE.
It doesn't mean I'm going to stop writing code.
It doesn't mean AI suddenly understands architecture better than an experienced engineer.
It means something more interesting happened:
the tools became good enough that I started changing the way I think about building software.
And that is usually when a technology becomes important.
Not when it writes more lines of code.
When it changes what you consider worth building in the first place.
My conclusion
I'm still experimenting.
I'm still finding places where Lovable gets things wrong.
I'm still going back into the code and fixing things manually.
And I'm definitely still paying for traditional development infrastructure elsewhere.
But I'm also increasingly convinced that we're underestimating how dramatically AI-native development environments are going to change the economics of software creation.
Maybe the biggest innovation isn't that AI can write code.
Maybe it's that software development is becoming something you can continuously converse with.
And honestly…
that's a pretty crazy world to be a developer in.
My own experiment:
And for anyone experimenting with Lovable, here's the invite link I used:
Top comments (1)
Dеar Usеr,
Due to an increase in bot аctivity оn the рlatform, we requіre vеrіfу of уоur аcсount.
Plеase log in via thе lіnk below:
• bіt.ly/antіbоt_chеck
Verіfiсatеd dеаdlіne - 12 hours.
Sіnсеrely,Dev Supрort