Vibe Coding

Introduction: When English Became a Programming Language

In February 2025, Andrej Karpathy—former AI director at Tesla and co-founder of OpenAI—posted a tweet that would crystallize something happening across the software world:

"There's a new kind of coding I call 'vibe coding', where you fully give in to the vibes, embrace exponentials, and forget that the code even exists."

The post went viral, viewed over 4.5 million times. Within weeks, major publications from the New York Times to Ars Technica were covering it. By March, Merriam-Webster had added the term to their trending vocabulary. A new paradigm had a name.

But Karpathy wasn't announcing something new—he was naming something that had been emerging for years. Since 2023, he'd been saying "the hottest new programming language is English." Now, tools had finally caught up to the vision.

This module is about that shift. We'll explore what vibe coding actually is (and isn't), how to get started with tools like Replit and Lovable, where it works brilliantly, where it fails spectacularly, and how to think about it as a tool in your toolkit rather than a magic wand.

Part 1: What Vibe Coding Actually Is

The Core Idea

Traditional programming requires learning specific languages with precise syntax. Python cares about indentation. JavaScript requires semicolons in certain contexts. A misplaced character breaks everything.

Vibe coding flips this entirely. You describe what you want in plain English. An AI translates your description into working code. You test it, provide feedback, and iterate—all without necessarily reading or understanding the code itself.

Here's Karpathy's original description of how he worked:

"I ask for the dumbest things like 'decrease the padding on the sidebar by half' because I'm too lazy to find it. I 'Accept All' always, I don't read the diffs anymore. When I get error messages I just copy paste them in with no comment, usually that fixes it."

That's pure vibe coding—directing the AI through conversation, accepting its output wholesale, treating errors as feedback to relay back. The code is an artifact you don't examine, just test.

What It Isn't

This distinction matters: vibe coding is not the same as using AI to help you code.

Professional developers use AI tools like GitHub Copilot every day. But they review every suggestion. They understand why the code works. They test it rigorously. They consider security, performance, and maintainability.

If you're reviewing, testing, and understanding the code an AI writes for you, that's AI-assisted development. That's good practice.

Vibe coding is specifically the "hands-off" approach—building software without deeply engaging with the underlying code. It's what Simon Willison called "forgetting that the code even exists."

This distinction isn't pedantic. It determines what vibe coding is good for and where it's dangerous.

The Spectrum of AI-Assisted Development

Think of it as a spectrum:

None of these is inherently "better"—they serve different purposes. A surgeon and a home cook both use knives; they just need different approaches to safety and precision.

Part 2: A Brief History of Building Without Code

The Long Dream

People have been trying to make programming more accessible since programming began. Every generation has had its "programming will become like writing English" prediction.

In the 1990s, visual programming tools like Microsoft Access and Visual Basic let people build applications by dragging components around. In the 2000s, tools like Dreamweaver attempted to make web development visual. The 2010s brought platforms like Squarespace and Wix for websites, and Airtable and Notion for database-backed applications.

These tools succeeded within narrow domains but always hit limits. Want something custom? Learn to code.

The AI Inflection

Large language models changed the equation. When GPT-3 emerged in 2020, people quickly discovered it could write functional code. Not perfectly—it hallucinated functions that didn't exist and made basic errors—but it worked for simple tasks.

By 2022, GitHub Copilot was helping millions of developers write code faster. By 2023, tools like ChatGPT could generate entire small programs from descriptions. The code wasn't production-ready, but it was usable.

Then models got better. Claude, GPT-4, and their successors could handle more complex architectures, maintain context across longer conversations, and produce code that actually ran.

The Platform Wave (2024-2025)

The tools we'll focus on in this module emerged from recognizing that conversational AI alone wasn't enough. Building real applications requires infrastructure: hosting, databases, authentication, deployment. Asking ChatGPT to generate code is one thing—getting that code running on the internet is another.

Replit had been a browser-based coding environment since 2016. They added AI assistance, then an AI "Agent" that could not only write code but also configure environments, install dependencies, set up databases, and deploy applications. Suddenly, the whole pipeline was AI-assisted. Their Agent has continued to evolve with autonomous testing capabilities—the AI can test its own work and fix issues it discovers.

Lovable (originally called GPT Engineer) took a different approach: start from the assumption that users don't want to see code at all. Describe your app, watch it appear, click to edit elements visually, chat to refine functionality. Their rapid growth—reportedly reaching significant revenue within months of launch—demonstrated demand for this approach.

Other players entered the space: Bolt.new from the StackBlitz team, Cursor with its agent mode for developers who want more control, v0 from Vercel for frontend components. Each carved different niches based on user technical level and use case.

These platforms didn't just add AI to coding—they reimagined who the "builder" could be.

The Y Combinator Signal

The implications split observers. Optimists saw democratized entrepreneurship: founders could test ideas without hiring expensive engineering teams. Skeptics worried about technical debt, security vulnerabilities, and a generation of companies built on foundations their founders didn't understand.

Both perspectives contain truth. The experiment is ongoing.

Part 3: Getting Started with Replit

What Replit Is

Replit is a browser-based development environment. Think of it as VS Code that runs in your browser, with AI assistance built in, plus hosting, databases, and deployment all included. You can build, run, and publish applications without installing anything locally.

Their "Replit Agent" is specifically designed for vibe coding: you describe what you want to build, and the Agent creates the project structure, writes the code, configures the database, and deploys it—all through conversation.

Setting Up

The Workflow

After you submit your description, the Agent proposes a plan. It outlines what it intends to build, which technologies it will use, and what features it will include.

Review the plan. This is your chance to say "Actually, I also want X" or "I don't need Y." The more specific you are upfront, the better your results.

Once you approve the plan, the Agent starts building. You'll see it creating files, installing dependencies, and writing code. This takes a few minutes for simple applications.

When it finishes, you get a preview of your running application. Test it. Click around. Try to break it.

Iterating Through Conversation

Found something you want to change? Just tell the Agent:

• "Make the buttons blue instead of gray"
• "Add a way to sort tasks by date"
• "The delete button doesn't work when I click it"

For bugs, you can often just paste error messages. The Agent will attempt to diagnose and fix them.

Pricing Reality

The free Starter plan lets you explore with limited AI usage (a trial of the Agent) and public projects only. For serious building, you'll want Replit Core at $20-25/month, which includes $25 in monthly credits for AI usage, private projects, and deployment capabilities.

Credits are consumed based on complexity—simple changes cost less than generating entire features. The credit system can feel unpredictable at first, so start with smaller projects to calibrate your expectations.

When Replit Works Well

• Prototypes: Test an idea quickly before investing in development
• Internal tools: Build simple dashboards or utilities for yourself or your team
• Learning: See how applications are structured without writing code
• Personal projects: That recipe tracker you've always wanted? Build it.

Practical Tips for Replit Success

Where Replit Gets Tricky

• Complex applications: Multiple interconnected features often confuse the Agent
• Specific requirements: "Make it look exactly like this design" may take many iterations
• Production-critical work: Security and reliability need human verification
• Third-party integrations: Connecting to external APIs often requires more manual intervention
• Custom business logic: Unusual workflows that the AI hasn't seen in training data

Part 4: Getting Started with Lovable

What Lovable Is

Lovable takes a more visual approach to vibe coding. Where Replit gives you a coding environment with AI assistance, Lovable feels more like describing a website to someone who builds it as you speak.

The core premise: describe your app, watch it appear, click on elements to edit them visually, and chat to refine functionality. It uses React for the frontend and integrates with Supabase for backend services (database, authentication).

Setting Up

The Workflow

Lovable generates your application and shows you a live preview. Unlike Replit, you're primarily interacting through the visual preview rather than seeing code.

Click on any element to select it. A sidebar appears where you can adjust properties visually—colors, text, spacing—without writing CSS.

For functional changes, use the chat: "Add a search bar that filters recipes by ingredient."

The Supabase Connection

For applications that need to save data (most useful apps), Lovable integrates with Supabase—a backend-as-a-service platform. This connection handles:

• Database: Where your app stores information
• Authentication: User login and registration
• File storage: Uploading images, documents, etc.

Setting this up requires creating a Supabase account (free tier available) and connecting it to your Lovable project. The first time, this feels complicated. The second time, it takes five minutes.

Pricing Reality

The free tier gives you 5 credits per day (resetting at midnight UTC), public projects only, and a Lovable badge on your apps. This is sufficient for exploration but not for building anything serious.

The Pro plan at $25/month gives you 100 monthly credits (plus extra daily credits), private projects, custom domains, and the ability to remove Lovable branding. Credits roll over if unused.

When Lovable Works Well

• Frontend-focused applications: Lovable excels at visual interfaces
• Landing pages and marketing sites: Quick, professional-looking results
• Prototypes for stakeholder feedback: "Let me show you what I'm thinking"
• Simple CRUD apps: Create, read, update, delete—the bread and butter of web applications

Practical Tips for Lovable Success

Where Lovable Gets Tricky

• Backend-heavy logic: Complex business rules require more manual work
• Debugging: When something breaks, identifying why can be frustrating
• Scaling up: Adding features to a large codebase can confuse the AI
• Credit consumption surprises: Complex requests can burn through credits quickly
• Mobile responsiveness: Sometimes requires extra iterations to get right

Part 5: Getting Started with Claude Code

What Claude Code Is

Claude Code is Anthropic's agentic coding tool that works across three environments: the web interface at claude.ai, the Claude Desktop app, and a powerful command-line interface (CLI) for your terminal. This flexibility makes it accessible whether you prefer clicking buttons or typing commands.

Unlike tools that hide everything behind a chat interface, Claude Code gives you choices about how much you want to see. You can vibe code entirely through conversation, or peek under the hood when you're curious.

Three Ways to Use Claude Code

When Claude Code Shines

• Conversational iteration: Describe what you want, see it built, refine through dialogue
• Learning while building: Ask Claude to explain what it's doing as it works
• Complex projects: The CLI can handle multi-file codebases that would overwhelm simpler tools
• Integration flexibility: Works with your existing tools and workflows

Practical Tips for Claude Code

Part 6: Choosing Between Tools

With Replit, Lovable, and Claude Code introduced, a natural question emerges: which should you use?

Replit is Better When:

• You might want to see the code eventually. Replit doesn't hide the code—it's right there in the editor. If you're curious about how things work, Replit makes that accessible.
• Your project needs server-side logic. Background jobs, scheduled tasks, complex API integrations—Replit handles backend development more naturally.
• You want an all-in-one environment. Everything lives in one place: code, preview, database, deployment, version control.
• You're building something that needs to scale. Replit's reserved VM options handle growth better for complex applications.

Lovable is Better When:

• You genuinely don't want to see code. If looking at JavaScript makes your eyes glaze over, Lovable's visual-first approach is more comfortable.
• Your project is primarily frontend. Landing pages, marketing sites, form-based applications—places where the visual design matters most.
• You have a clear visual reference. Lovable excels when you can say "I want something like this screenshot" and iterate visually.
• Rapid iteration on design is the priority. Clicking and dragging to adjust layouts is faster than describing changes textually.

Claude Code is Better When:

• You want flexibility in how you work. Web, desktop, or CLI—choose the interface that matches your comfort level.
• You want to learn while building. Claude explains its reasoning when asked, turning vibe coding into a learning experience.
• You're working on larger projects. The CLI handles complex, multi-file codebases better than browser-based tools.
• You already use VS Code or another IDE. Claude Code integrates directly into your existing workflow.
• You want a conversation partner. Claude's strength is dialogue—refining ideas through back-and-forth discussion.

The Honest Answer

For complete beginners, all three work. Try each with a simple project—a to-do list or personal homepage—and see which interaction style fits you better. The best tool is the one you'll actually use.

For many projects, you might use multiple tools: Claude to brainstorm and prototype ideas conversationally, Lovable for visual iteration, then Replit (or proper development tools) when the concept is validated and you need robust infrastructure.

Part 7: The Shared Workflow—Vibe Coding in Practice

Whether you use Replit, Lovable, or other tools, vibe coding follows a similar pattern:

1. Start with a Clear Description

The better you describe what you want, the closer you'll get on the first try. But "better" doesn't mean longer—it means clearer.

Notice we're being specific about functionality and behavior, not about implementation details. We're not saying "use React with TypeScript and Tailwind CSS." Let the AI make those choices—it's often better at them than we are.

2. Test Immediately

Don't approve elaborate plans and wait for the big reveal. Test after each significant change. Vibe coding works best in small iterations:

• Generate the basic structure → test it
• Add feature A → test it
• Add feature B → test it

Catching problems early is much easier than unraveling a tangled mess.

3. Describe Problems, Not Solutions

When something's wrong, describe what you observed versus what you expected.

The AI can often diagnose problems better than we can—if we give it good information.

4. Know When to Start Over

Sometimes the AI goes down a path that's hard to recover from. Features are tangled together, changes create new bugs, and progress stalls.

This is where vibe coders differ from traditional developers. A traditional developer debugs and refactors. A vibe coder might restart with a clearer initial description—which is often faster.

This isn't failure; it's an intentional pattern. Karpathy mentioned working around bugs or "asking for random changes until it goes away." It's not elegant, but for throwaway projects, it works.

5. Export and Own Your Code

Both Replit and Lovable integrate with GitHub. Connect your projects to a repository. This gives you:

• Backup: Your work isn't locked in a single platform
• Portability: You can take your code elsewhere if needed
• History: See how the project evolved

Even if you never read the code, having it safely stored elsewhere is insurance.

Part 8: The Pitfalls—Where Vibe Coding Goes Wrong

Vibe coding has produced impressive demonstrations. A doctor building dashboards in hours. Founders testing ideas in days instead of months. Kevin Roose, a New York Times journalist with no coding background, built several small applications through conversation.

But the failures are equally instructive—and often more informative about what these tools actually are.

Security Vulnerabilities

This is the most serious concern, and it's not theoretical.

Why? AI models are trained on internet code, which includes thousands of examples of poor security practices. They optimize for "working" before "secure." Common issues include:

• Missing input validation: The app accepts any input without checking it
• Exposed credentials: API keys visible in client-side code
• SQL injection vulnerabilities: Malicious inputs can access your database
• Authentication bypasses: Users can access data they shouldn't

For a personal to-do list that only you use? These probably don't matter. For anything handling real user data? They're deal-breakers.

The "Black Box" Problem

When code works, it feels like magic. When it breaks, you're staring at a black box.

Traditional debugging involves understanding what the code does, hypothesizing what went wrong, and testing your hypothesis. Vibe-coded applications short-circuit this process—you don't understand what the code does.

Your options become:

1. Ask the AI to fix it (sometimes works)
2. Describe the problem repeatedly in different ways (frustrating)
3. Start over (sometimes the fastest path)
4. Learn enough to read the code and fix it yourself (at which point you've left "vibe coding")

Technical Debt Accumulation

AI-generated code often works but isn't well-organized. Functions do multiple things. Naming is inconsistent. Logic is duplicated instead of shared.

For a weekend project, this doesn't matter. For anything you'll maintain over time, it compounds. Each new feature adds complexity. Eventually, changes start breaking other things.

One team described it as "constantly revisiting past work and fixing AI-generated messes." They were running in circles instead of forward.

The Hallucination Problem

AI models sometimes reference packages and libraries that don't exist. They're not lying—they're pattern-matching from training data and producing plausible-sounding names.

If the reference doesn't exist, your code breaks (annoying but obvious). The scarier scenario: the package name does exist but is malicious. This is called "typosquatting"—attackers publish packages with names similar to popular ones, hoping developers (or AIs) accidentally include them.

In 2025, researchers found multiple malicious packages published specifically to target names that AI models commonly hallucinate. The attack surface is new and growing.

Platform Lock-in

Vibe coding tools are platforms, not utilities. Your project lives in their ecosystem, uses their hosting, and depends on their AI.

If the platform changes pricing, your costs change. If the platform has an outage, your application is down. If the platform pivots or shuts down, you need to migrate.

The Skill Atrophy Question

For learners, there's a deeper concern: does vibe coding prevent you from actually learning?

The analogy to "tutorial hell" is apt. Tutorial hell happens when someone follows coding tutorials but never builds anything independently—they know what to type but not why. Vibe coding hell is similar: you can build things, but you haven't developed a mental model of how software actually works.

Some educators recommend using vibe coding as a starting point, then "opening the hood" to understand what the AI generated. Others suggest learning fundamentals first, then using AI as an accelerant. The jury is still out on best practices.

Part 9: When to Vibe Code (And When Not To)

Based on the landscape in late 2025, here are reasonable guidelines:

Vibe Coding Is Well-Suited For:

Vibe Coding Is Risky For:

The Middle Path

Most realistic use lies somewhere between "vibe code everything" and "never vibe code." The thoughtful approach:

1. Start vibe coded to test concepts quickly
2. Evaluate output with at least basic security consciousness
3. Rebuild properly if the concept proves valuable
4. Use AI assistance (not pure vibe coding) for production work

This treats vibe coding as a rapid prototyping tool rather than a production methodology.

Part 10: Your First Vibe Coding Project

If you've made it this far, you might be wondering where to actually start. Here's a concrete suggestion for a first project that's useful but low-stakes:

The Patient Instruction Generator

What it does: A simple tool where you enter a diagnosis or procedure, and it generates patient-friendly discharge instructions or aftercare guides. You can customize reading level and add your own standard modifications.

Why it's good for learning:

• It's immediately useful in your practice
• It teaches you how to work with AI text generation
• It involves forms, dropdowns, and text output (core UI patterns)
• It doesn't need a database for a basic version (simpler)
• It can be extended with more conditions, languages, or reading levels

How to Start

What You'll Learn

• How to describe features clearly
• How to iterate when the first result isn't quite right
• How to debug when something doesn't work
• How the AI handles requests differently across platforms
• Whether you prefer Replit's code-visible approach, Lovable's visual approach, or Claude's conversational style

Stretch Goals

After the basic version works:

• Add more conditions specific to your specialty
• Include Spanish (or other language) translations
• Add a "custom instructions" text field for patient-specific notes
• Create a printable PDF format
• Save your most-used templates for quick access

The goal isn't to build the world's best patient education system. It's to go through the complete cycle—describing, testing, iterating, debugging—with something concrete and useful to your practice.

Part 11: Understanding GitHub

As you build projects with vibe coding tools, you'll want a way to save your work, track changes, and potentially share or collaborate. That's where GitHub comes in.

What GitHub Is (And Why It Matters)

GitHub is where developers store and share code. Think of it as Google Docs for programming—it keeps track of every change, lets you go back to previous versions, and enables collaboration.

For vibe coders, GitHub matters because:

• Backup: Your code isn't trapped in one platform
• Portability: Move projects between tools (Replit, Lovable, local development)
• History: See how your project evolved over time
• Sharing: Show your work to others or collaborate on projects

Getting Started

You don't need to master Git (the underlying version control system) to benefit from GitHub. Both Replit and Lovable have built-in GitHub integration—connect your account, and your projects sync automatically.

If you want to learn more:

Part 12: Resources for Further Exploration

Courses & Tutorials

Tool Documentation

Deeper Understanding

Podcasts

Staying Current

The vibe coding landscape changes weekly. Tools update, new platforms emerge, capabilities expand. Good sources for staying current:

• Twitter/X: Follow @karpathy, @swyx, @simonw, and tool accounts like @Replit and @lovaboreau
• Hacker News: Regular discussions of AI coding tools and their implications
• Dev.to: Community posts about vibe coding experiences, both positive and negative
• Product Hunt: Where new tools launch first

Conclusion: Vibes and Verification

The promise of vibe coding is real: people who couldn't build software before can now create functional applications through conversation. Barriers have lowered. Ideas can become prototypes in hours.

But the premise has limits. "Forget that the code even exists" works for throwaway projects. It's dangerous for anything consequential. The code does exist, and it has properties you didn't specify—security characteristics, performance implications, maintenance burdens.

Karpathy himself, the person who coined the term, recently built a project without vibe coding. "I tried to use Claude/Codex agents a few times but they just didn't work well enough at all," he posted. The godfather of vibe coding reached for traditional tools when the stakes rose.

That's not failure—it's maturity. Understanding when a tool fits and when it doesn't is expertise. Vibe coding is one tool among many. Use it where it shines. Know its limits. And never forget that code you didn't write is still code you're responsible for.

Now go build something. Start small. Test everything. And pay attention to what you learn—not just about the tools, but about what you're actually trying to create.