Vibe Coding with Limits — How to Build Apps in the Age of AI

Vibe coding with limits

The concept of "vibe coding" – describing what you want to an AI and letting it generate the code – has captured developers' imagination. The results can be impressive: functioning prototypes materialized from simple descriptions, complex algorithms implemented without wrestling with syntax, and UIs assembled without painstaking CSS tweaks.

But any developer who has experimented with this approach inevitably runs into its limitations. After a few rounds of prompts, what started as a clean implementation often becomes unwieldy. Subtle bugs creep in that become increasingly difficult to resolve. The promise of effortless development gives way to a familiar frustration — now compounded by code you didn't write yourself.

The reality in 2025 is that developers still need to understand the code they're shipping. AI can accelerate development dramatically, but it can't (yet) replace the critical thinking and system design skills that make applications robust and maintainable.

So what's the optimal approach to building fullstack applications while leveraging these powerful new tools?

Understanding the AI tooling spectrum

AI coding tools exist along a spectrum of abstraction, each offering different levels of assistance and control. Which tool to reach for depends on your very-own experience and individual goals.

Let’s take a closer look at the levels of abstractions and where to place the most popular AI software development tools.

Low-level: AI-assisted code writing

At the bottom of the abstraction ladder are tools that help you write code more efficiently without changing your fundamental workflow.

• Claude Code: An AI assistant that integrates with your terminal, acting as a pair programmer that responds to natural language.
• Windsurf/Cursor: IDEs built specifically around AI assistance, improving the coding experience while letting developers maintain full control.
• GitHub Copilot: An "AI pair programmer" that comes with VS Code.

These tools assist in writing code by integrating directly into the developer’s familiar tooling and workflows. They're particularly useful for workflows like generating boilerplate, writing glue code (like basic CRUD operations or DTOs), or implementing tests.

Mid-level: Prompt-first with access to codebase

The middle of the spectrum consists of tools that use prompts as the primary interface but give you direct access to modify the generated code. This often works by "ejecting" your code into a GitHub repo in which you can make manual changes when needed.

Examples of these kinds of tools are: co.dev, Lovable, v0, Replit, Bolt, …

These approaches strike a balance between handing over the bulk of the work to an AI while maintaining precise control when needed.

High-level abstraction: "No-code" AI platforms

At the highest level of abstraction are platforms that are the evolution of "no code" app building tools that have emerged in the past years.

• Bubble.io: A visual programming platform with AI assistance.
• Glide: Creates applications from spreadsheets with AI-driven features.
• Gamma: Builds interactive presentations and lightweight apps through natural language.

While these tools maximize productivity for simple use cases, such as basic CRUD applications or well-defined, single-task applications (like a todo app, a chess game or a personal routine tracker), they also don’t offer any paths for customizing the code directly and thus don’t lend themselves well for applications with more complex requirements.

Code vs Infrastructure: Where AI can't help

As powerful as AI has become at generating code, there's a critical component of application development it can't replace: the compute infrastructure your code is going to run on as well as the storage infrastructure.

No matter how well your AI-generated application may work, it still needs a place to actually run. You need:

• Compute resources that execute your code reliably
• Storage systems that maintain your data with appropriate guarantees
• Networking infrastructure that connects your components securely

Platforms like Vercel provide the compute infrastructure and make deployment of your application easy — however, your application still needs to talk to a database.

Traditional databases that run on heavy-weight operating systems aren’t fit for the modern age of AI-based software development due to their high resource consumption, configuration overhead and slow cold starts.

Prisma Postgres: The database designed for the age of AI development

This is where solutions like Prisma Postgres provide particular value! Prisma Postgres is the first serverless database built on highly-efficient unikernels, designed to run thousands of instances on a single machine.

It offers the reliability developers need without the operational complexity that AI can't abstract away. When AI helps you move faster on code generation, you need infrastructure that keeps pace – scalable, on-demand, and requiring minimal configuration.

To try out Prisma Postgres, simply run this command in your terminal:

Prisma Postgres also integrates directly with your favorite LLM and AI coding environment via the Model Context Protocol (MCP).

Simply add it to the MCP configuration of your desired AI tool using this JSON snippet:

Learn more about this in the Prisma Postgres documentation.

When to use AI?

While AI has become remarkably powerful at writing code, it's not (yet) replacing developers. Understanding where AI excels and where human expertise remains essential is key to using AI tools effectively.

Let’s look at a couple of use cases and scenarios that the AI tools at the lower end of the abstraction spectrum (like Cursor, Windsurf, GitHub Copilot, …) are a good fit for.

Routine and monotonous tasks / Glue code

Tasks like implementing CRUD operations, setting up authentication flows, or creating standard API endpoints follow well-established patterns that AI can reproduce reliably. These are perfect candidates for delegation to AI assistants, freeing you to focus on more creative aspects of development.

Coding by specification

When you have clear requirements and specifications, AI can efficiently translate them into working implementations. This is especially true for features with well-defined inputs, outputs, and behaviors.

Rapid prototyping

AI performs really well at rapidly creating functional prototypes that demonstrate concepts and validate ideas. When exploring ideas or testing new features with users, AI-generated code can dramatically accelerate the feedback cycle, even if you plan to refactor for production or just build an initial version with low-quality "throw-away code".

You still need to understand your code (for now!)

AI represents the next step on the programming abstraction ladder – from machine code to assembly to high-level languages to frameworks and now to natural language interfaces. The same rules that governed previous transitions apply here as well:

• Higher abstraction can increase productivity: Describing features in natural language is faster than writing them line by line.
• But abstractions have leaks: When things go wrong (and they will), understanding what's happening beneath the abstraction becomes essential.
• Debugging complexity doesn't disappear: It often increases as the gap between what you specified and what was implemented widens.

The most effective developers approach AI as a powerful tool rather than a replacement for understanding. They use AI to accelerate development while maintaining sufficient knowledge of the generated code to debug, optimize, and maintain it over time.

Conclusion

Building fullstack applications in the age of AI isn't about blindly generating code through prompts – it's about finding the right balance of AI acceleration and human oversight.

The most successful developers in this new era will be those who:

• Leverage AI for appropriate tasks while maintaining architectural control
• Choose infrastructure that complements AI-accelerated development
• Understand the code they ship, even when they didn't write every line themselves
• Use type-safe tools like Prisma ORM that provide guardrails for both human and AI-written code

As AI capabilities continue to evolve, this balance will shift. But for now, the winning approach combines the best of both worlds: the creativity and judgment of human developers with the speed and pattern recognition of AI assistants.