Starting from Scratch

If you've seen the term "vibe coding" and wondered what it actually means, and whether it has anything to do with you, you're in the right place. This is the plain-English guide to one of the most significant shifts in how software gets made.

The simple definition

Vibe coding is a way of building software where you describe what you want in natural language, plain English, and let an AI assistant generate the actual code for you. Instead of learning programming languages, syntax, or frameworks, you have a conversation. You describe your idea; the AI builds it.

That's it. But the implications are enormous.

Where the term came from

The phrase was coined in February 2025 by Andrej Karpathy, an AI researcher who previously led AI development at Tesla and was one of the founding team at OpenAI. In a widely shared post, he described a style of coding where you "fully give in to the vibes", using AI so fluidly that the distinction between describing and building collapses.

The term caught fire because it named something people were already doing. Anyone who had used ChatGPT or Claude to write a piece of code, tweak a website, or fix something they didn't understand was already vibe coding. Karpathy just gave it a name.

What makes it different from traditional coding

Traditional software development requires fluency in a programming language. You need to understand syntax, data structures, logic flow, and debugging. Learning to code meaningfully takes months or years. This creates a gap between people who can build software and people who have ideas for software.

Vibe coding closes that gap. You don't need to speak the language, you need to be able to describe what you want clearly and evaluate whether what you get back is right. Those are skills most people already have.

Is it really coding?

This question comes up a lot, and the honest answer is: it depends on what you think coding means. If coding means writing code, then vibe coding isn't traditional coding. But if coding means building functional software, making things that work, then yes, absolutely. The code is real. The apps are real. The products people are shipping are real.

Think of it like the difference between designing a building and laying the bricks. An architect doesn't lay every brick, but they're still the person who made the building happen. Vibe coders are architects.

Why it matters right now

Y Combinator, the world's most prestigious startup accelerator, reported that in its Winter 2025 batch, 25% of companies had codebases that were 95% AI-generated. This isn't a hobby trend. It's how real products are getting built by teams that ship fast, iterate constantly, and reach market ahead of traditionally-staffed engineering teams.

The question is no longer whether vibe coding is legitimate. It's whether you're going to learn it before your competitors do.

Vibe coding didn't come from nowhere. It's the latest chapter in a story that started decades ago, a story about making software creation more human. Understanding that history helps you see why this moment is different from all the previous ones.

The original era: coding as a specialist skill

For most of computing history, building software required deep technical training. Early programmers worked with punch cards, then assembly language, then increasingly higher-level languages like FORTRAN, C, and BASIC. Each new language made programming slightly more accessible, but it was still firmly in the domain of specialists.

By the 1990s, languages like Java and Python lowered the barrier further. Web development brought HTML and JavaScript, which millions of people learned to use. But even so, building anything meaningful required a real investment in technical learning, typically months or years.

The no-code revolution (2010s)

The first major shift came with the no-code and low-code movement. Tools like Squarespace, Wix, and later Webflow let people build websites by dragging and dropping. Platforms like Airtable and Notion let people build databases and workflows without touching code. Zapier let people connect apps and automate tasks through visual interfaces.

These tools were genuinely transformative. Millions of people built things they never could have before. But they came with a ceiling: you could only build what the tool was designed for. Step outside those boundaries, and you hit a wall.

The AI moment (2022-2024)

The release of ChatGPT in late 2022 changed the conversation. For the first time, people could describe a coding problem in plain English and receive working code in response. GitHub Copilot had already introduced AI code completion for developers, but ChatGPT made it accessible to everyone.

Within months, a new pattern emerged: people who had never written a line of code were building functional tools, automating workflows, and fixing bugs, all by describing their problems in natural language and iterating on the AI's output. The no-code ceiling had been broken.

Vibe coding: the next chapter (2025-present)

Andrej Karpathy's coining of "vibe coding" in early 2025 named something that was already happening at scale. The tools had become sophisticated enough, Cursor, Bolt, Replit AI, Claude, and others, that the entire loop of describing, generating, reviewing, and deploying could happen in a single environment, in a single session.

Collins Dictionary made it Word of the Year. Millions of first-time builders launched projects. Startups were being built with AI-generated codebases. The shift from "coding as specialist skill" to "building as human skill" had arrived.

Most people who struggle with vibe coding aren't struggling because of the tools. They're struggling because of how they're thinking about it. The good news: the right mindset is learnable, and it has nothing to do with technical ability.

You are the director, not the developer

The most important shift is this: in vibe coding, your job is to direct, not to execute. You are the person with the vision, the one who knows what the finished product should feel like, what problem it solves, and what a good version looks like. The AI is the developer. It does the actual building.

This means your most valuable skill is clarity of vision, not technical knowledge. The more precisely you can describe what you want, what it does, who it's for, what it looks like, the better the AI can build it.

Embrace iteration, it's the whole game

First-time vibe coders often expect to write one prompt and receive a finished product. That's not how it works, and expecting it to be will make you frustrated fast.

Vibe coding is iterative by nature. Your first prompt gets you a starting point. You look at what came back, identify what's right and what isn't, and give feedback. Then you look again. Then you refine again. The finished product emerges across many rounds of conversation, not in one shot.

Get comfortable with not understanding everything

One of the most uncomfortable things for new vibe coders is looking at AI-generated code and having no idea what it does. This is completely normal, and you don't need to fix it before you start building.

You don't need to understand every line of code your AI produces. You need to understand whether the thing it built works the way you wanted. That's a different, and much more achievable, skill.

Start smaller than feels right

Every beginner's first instinct is to build the full thing. Resist it. The most common reason vibe coding projects fail is scope creep, adding features before the core works, building complexity before building simplicity.

Start with the absolute minimum version of your idea. One screen. One action. One thing it does. Get that working. Then add the next thing. Building in layers is how professionals work, and it's even more important for beginners.

Curiosity beats frustration

When something doesn't work, there are two responses: frustration ("this doesn't work") and curiosity ("interesting, why didn't that work?"). The first leads to giving up. The second leads to learning.

When the AI produces something unexpected, treat it as data. Ask: what did I describe that made it think this was right? What should I say differently? That habit of curious investigation is the single trait that most reliably separates vibe coders who ship things from ones who don't.

Before you invest time learning anything, it's fair to ask: what will I actually be able to build? This article gives you an honest tour of what vibe coding can and can't produce, so you can go in with the right expectations.

Web apps and tools

This is where vibe coding shines most brightly. Web apps, things that run in a browser, are well-suited to AI generation because the landscape is well-understood and well-documented. Vibe coders are building:

• Productivity tools (habit trackers, project managers, dashboards)
• Client-facing tools (booking systems, quote calculators, portals)
• Internal tools for small teams (CRMs, inventory trackers, report generators)
• Marketplaces and directories
• SaaS micro-products with actual paying users

The complexity ceiling is higher than most people expect. Vibe coders are shipping products that charge real money to real customers.

Games

Games are one of the most exciting and surprisingly accessible categories for vibe coders. Simple browser-based games, think classic arcade games, puzzle games, word games, and card games, can be generated in a single session.

• Trivia games with custom questions and categories
• Platformers and endless runners (simple versions)
• Word games, memory games, and puzzle games
• Multiplayer card games and board game digital adaptations
• Simple RPGs with story-driven mechanics

Websites and landing pages

Static websites, portfolio sites, and marketing landing pages are among the easiest things to build with vibe coding. You describe the layout, the content, the brand, and the feel, the AI builds it. Coupled with deployment tools, you can go from description to live URL in under an hour.

Automations and scripts

If you find yourself doing the same thing repeatedly, processing data, sending emails, organising files, pulling information from one place and putting it somewhere else, that's a strong candidate for automation via vibe coding.

What's harder to build

To set honest expectations: certain things are genuinely hard for vibe coders to produce without more technical knowledge. Complex, real-time multiplayer games with sophisticated physics require careful human oversight. Anything involving sensitive data security needs an expert to review the AI's choices. Large-scale systems with thousands of concurrent users require architectural decisions that are hard to delegate entirely to AI.

One of the most common things people think when they hear about vibe coding is "that sounds interesting, but it's probably not for someone like me." This article is about dismantling that thought.

Entrepreneurs and founders

If you have a business idea that requires a software product, vibe coding can get you to a testable prototype without hiring a developer. Speed matters enormously in early-stage businesses, being able to validate an idea with a working demo in days rather than months can be the difference between pursuing something and letting it die.

Freelancers and consultants

If you help clients with their business, you probably encounter the same problems over and over. Vibe coding lets you build custom tools that solve those problems, and either give them to clients as part of your service, or productise them as a separate offering.

Creators and artists

Writers, illustrators, musicians, and content creators are finding vibe coding gives them a way to build things that support their work, or become work in themselves. Interactive fiction, art portfolio sites, fan experiences, games, creative tools. All within reach for a committed creator.

People with a specific problem to solve

You don't need a startup idea or a business plan. You just need a problem that software could solve. Maybe it's organising your team's schedule. Maybe it's a tool to track your reading list. Maybe it's a simple game you want to play with your kids. Vibe coding for personal use is deeply underrated.

People who've tried to learn to code and got stuck

There are millions of people who spent months trying to learn Python or JavaScript, got stuck, felt frustrated, and gave up. Vibe coding offers an alternative route into building that doesn't require that investment. Many people who couldn't crack the code-first approach find the describe-first approach intuitive and fast.

Who it's harder for

Vibe coding is less suited to people who need to work with large, complex, existing codebases where the AI doesn't have full context. It's also harder if your project requires deep specialist knowledge (cryptography, real-time signal processing, regulated industries). These aren't barriers to starting, but they're good to know about.

Like any new discipline, vibe coding has its own tools, communities, culture, and vocabulary. Before you start building, it helps to have a map. This article gives you the lay of the land.

The three layers of the ecosystem

The vibe coding world is built on three layers that work together: AI assistants (the intelligence that generates code), coding environments (the place where you work and see your project take shape), and deployment platforms (where finished projects live so others can use them).

Layer 1: AI Assistants

These are the core of vibe coding, the language models you converse with to describe what you want built. The major players are Claude (Anthropic), ChatGPT (OpenAI), and Gemini (Google). Each has different strengths; we cover them in detail in Article 9.

Layer 2: Coding Environments

These are the platforms where you work. Some environments are fully browser-based (Replit, Bolt, Lovable); others are desktop apps (Cursor, Windsurf). Beginners typically start with browser-based tools to avoid setup friction.

Layer 3: Deployment

Once you've built something, you need somewhere to put it. Deployment platforms like Vercel, Netlify, and Railway take your project and make it live on the web. Many beginner tools include one-click deployment built in.

The key communities

• X (Twitter), where most real-time vibe coding conversation happens
• Reddit, r/vibecoding and r/nocode for questions and project sharing
• Discord servers for the major tools (Cursor, Bolt, Replit)
• Indie Hackers, a community of people building small software businesses
• Makermint, our own creator community built for vibe coders

The culture

Vibe coding culture tends to be open, share-first, and genuinely encouraging of beginners. The ethos is: build in public, show your process, don't gatekeep. People share their prompts, their failures, and their breakthroughs. The community celebrates shipping something imperfect over planning something perfect forever.

The vocabulary

A few terms you'll encounter: MVP (minimum viable product, the simplest version that demonstrates your idea); prompt (the description you give the AI); iteration (one round of feedback and refinement); deploy (make your project live on the internet); full-stack (both the front end a user sees and the back end that stores data and handles logic).

This is the question most people ask before they start, and it deserves a straight answer, not a hype-filled promise. So here it is.

Yes, but 'real' has context

You can absolutely build real, functional things without knowing how to code. Real means things that work: apps that run, tools that solve problems, games that are playable, sites that load. Not mockups or presentations. Actual working software.

The context is scope. A vibe coder without programming knowledge can build surprisingly sophisticated things, but not everything. The more complex the thing, the more back-and-forth you'll need.

What non-coders are genuinely shipping

• Niche SaaS tools with paying customers
• Internal business tools that replace messy spreadsheets
• Portfolio sites and marketing pages for their businesses
• Simple games built for fun or for their kids
• Personal productivity tools they use every day
• Automations that save them hours per week

Where things go wrong, and how to avoid it

Scope creep: The most common failure mode is trying to build too much at once. Every time something works, you think of five more features. Resist this. Ship the simple version. Add features after.

Vague descriptions: "Build me an app to manage my projects" is too vague. The AI will make dozens of decisions you didn't specify. The more precise your description, the better the output.

Giving up after the first failure: The AI will produce things that don't work. This is not a sign that you're doing it wrong, it's part of the process. The ability to stay curious and keep iterating is the most important skill.

Setting yourself up for success

Vibe coders who succeed tend to have three things in common: they start with a specific, well-scoped idea; they're willing to iterate rather than expecting perfection; and they know when to ask for help.

Walk into the vibe coding world and you'll find dozens of tools all claiming to be the best one. This guide cuts through it. Here's exactly what each type of tool does, the top picks for beginners, and the simplest way to get started today.

The three types of tools

Every vibe coding setup involves some combination of three things: an AI assistant (generates the code), a coding environment (where you work and test), and a deployment tool (makes your project live). Many modern platforms combine all three.

All-in-one beginner platforms

Bolt is the clearest recommendation for complete beginners. Open it in your browser, type a description, and it generates a working version instantly. No account setup, no configuration, no installation.

Replit pairs an AI assistant with a full online coding environment and one-click deployment. It's browser-based, free to start, and has a strong community.

Lovable is a newer platform designed specifically for non-developers who want to build web apps. Good for people who want something between Bolt's speed and Replit's depth.

AI-first coding environments (more control)

Cursor is a code editor with deep AI integration, built on top of VS Code. It gives you full visibility into the code the AI produces, making it a good choice if you want to learn what's happening under the hood.

Windsurf is a newer entry similar to Cursor, with strong AI-first features. Worth exploring once you're comfortable with the basics.

What you don't need to worry about yet

You don't need to install anything before your first project. You don't need to understand what an IDE or a package manager is. Start with Bolt, build something small, and let the tools you need emerge from what you're trying to do.

Three major AI assistants dominate the vibe coding world. Each has genuine strengths, and knowing what each one is best at helps you make better choices, especially as your projects grow in complexity.

What all three have in common

Claude, ChatGPT, and Gemini are all large language models (LLMs), AI systems trained on enormous amounts of text, including code, documentation, tutorials, and technical writing. All three can understand natural language descriptions and produce working code in response.

Claude (by Anthropic)

Claude is widely regarded by vibe coders as particularly strong at following complex instructions, maintaining context across long conversations, and producing clean, readable code. It tends to be precise about what it doesn't know, which is useful when you're working without deep technical knowledge yourself.

Claude is the AI powering Makermint's creator tools, and is built into several of the leading vibe coding environments.

ChatGPT (by OpenAI)

ChatGPT was the tool that introduced most of the world to AI conversation, and it remains extremely capable. GPT-4o is strong at code generation, debugging, and explaining technical concepts in plain language. Its plugin and tool ecosystem is extensive. It's a reliable choice and has the largest user community.

Gemini (by Google)

Google's Gemini is deeply integrated into Google's own products and can be particularly useful if your project involves Google services or data. For most vibe coding beginners, Gemini is less commonly the first choice, but it's strong in contexts where Google's ecosystem is relevant.

Which one should you use?

For most beginners: start with whatever is built into the tool you're using. When you start working directly with AI assistants, Claude and ChatGPT are the two strongest general-purpose choices for coding. Try both on the same problem and see which output you find clearer.

You don't need to spend days setting things up before you build something. This guide gets you from zero to a working project in your first 30 minutes, with nothing to install.

Before you open any tool: spend 5 minutes on your idea

The most valuable thing you can do before you touch any tool is get clear on what you want to build. Open a notes app and write down:

• What does this do? (One sentence)
• Who is it for?
• What does the main screen look like?
• What is the one most important thing it does?

Minute 5-10: Open your tool and set up an account

If you're building with Makermint, sign in and open a new project. If you're using Bolt, go to bolt.new in your browser. No account needed for your first build. Replit requires a free account, which takes two minutes to create.

Minute 10-20: Write your first prompt

This is the part most people overthink. You don't need a perfect prompt, you need a specific one. Take what you wrote and turn it into a paragraph. Include what the app does, what the main screen shows, what the user can do, and any strong design preferences. Submit it. Don't second-guess it.

Minute 20-30: Look at what came back

The AI will produce something. Before you give any feedback, take a full minute to look at it properly. Ask yourself:

• Does the overall structure match what I had in mind?
• What's right that I want to keep?
• What's the single most important thing that's wrong or missing?

Then give one specific piece of feedback. Not five things, one. The most important thing. Fix that, look again, and repeat.

You've started

That's your first 30 minutes. You've described something, received a working version, and given your first feedback. You are now a vibe coder. Everything else you'll learn is refinement of this loop.

The AI is only as good as what you tell it. Writing clear, specific, detailed prompts is the foundational skill of vibe coding, and it's completely learnable. Here's the framework.

The core principle: specificity wins

The single most important thing to understand about prompting is this: vague prompts produce vague results. When you leave things unspecified, the AI makes decisions for you, and those decisions probably don't match your vision.

The four-question framework

Before writing any prompt, answer these four questions:

• What does this do? Describe the purpose in one specific sentence.
• Who uses it? Describe the person using it, even if that's just you.
• What does the main screen look like? Describe what you see when you open it.
• What's the one most important thing it needs to do? Start with one core feature.

Turn those answers into a paragraph and you have your starting prompt.

Prompts for different situations

Starting a new project: Include everything from the four-question framework. Add design preferences and platform details.

Giving refinement feedback: Be specific about what to change: "Move the button to the bottom right", "Make the font larger", "Add a search bar at the top".

Reporting an error: Describe what you tried, what you expected, and what actually happened. The more precisely you describe the failure, the better the fix.

Adding a new feature: Describe it in isolation first: what it is, where it lives, how it works, and what it connects to.

The prompting muscle

Writing prompts is a skill that improves with practice. Your first prompts won't be great, that's fine. Every prompt teaches you something about the next one. By your third or fourth project, you'll have a prompting style that works for you.

Most tutorials make vibe coding look like magic: one prompt, instant perfect result. The reality is different, and knowing the real rhythm makes you a much more effective builder.

The honest shape of a vibe coding session

A real vibe coding session looks like this: you start with a description, get something back, find three things that are right and two that aren't, give feedback on the most important wrong thing, get a revised version, find something new to refine, give feedback again. This continues until you have something you're happy with.

That's not a failure mode. That's the process. The best vibe coders are not the ones who write perfect prompts, they're the ones who iterate efficiently.

The three phases of every build

Phase 1: Rough scaffolding. Your first prompt produces a rough structure. Don't get attached to details. The goal is to get the basic shape right: does it have the right screens? The right main interaction? The right general layout?

Phase 2: Core functionality. Once the structure is right, focus on making the most important thing work. Depth before breadth.

Phase 3: Polish and edge cases. Only after the core works do you think about making things look good, handling unusual inputs, adding secondary features, and preparing for others to use it.

Managing your energy in a session

Long vibe coding sessions can accumulate complexity in unhelpful ways. If you've been working on the same thing for two hours and you're going in circles, stop. Save the current state, step away, and come back fresh.

The "fresh conversation" reset

When a conversation with an AI gets long and tangled, start a new conversation. Paste in a clear summary of where you are and what you need next. This "fresh conversation reset" is one of the most powerful techniques experienced vibe coders use.

The AI will get things wrong. This isn't a flaw, it's a certainty. Knowing what to do when it happens is what separates vibe coders who finish projects from those who give up halfway.

First: accept that this is normal

Debugging is not a sign that you failed. It's a sign that you're building something real. Every developer, AI-assisted or not, spends a significant proportion of their time finding and fixing things that don't work.

The common types of failure

It built the wrong thing: The AI produced something that works but isn't what you described. The fix: describe the specific difference between what you got and what you wanted. Be precise.

It broke something that was working: You asked for a new feature, and now something else broke. The fix: describe what was working, what you asked for, and what broke. Ask the AI to restore the original behaviour while keeping the new feature.

It produced an error you don't understand: Copy the error message exactly and paste it to the AI. Add: "I was trying to [describe the action] when this happened."

It loops, fixing one thing and breaking another: This is a signal to stop and reset. Start a new conversation. Describe your project's current state clearly. Address only the single most important issue.

The debugging mindset

The key to effective debugging without code knowledge is treating every failure as information. Ask: what does this failure tell me about what went wrong? What was ambiguous in my description?

When to ask for help

If you've tried three different approaches to the same problem and nothing is working, that's a good time to ask for outside input. The Makermint creator community and Discord servers for your tool of choice are good places to get a fresh perspective.

The project you choose first matters more than most beginners realise. The right first project gives you a quick win, builds confidence, and teaches you the workflow. The wrong one leads to frustration.

The three rules for a good first project

Rule 1: It should be useful to you personally. The best first project is something you actually want. Personal investment keeps you going when things get difficult.

Rule 2: It should be describable in one sentence. If you can't explain your project in one clear sentence, it's too complex for a first attempt. The one-sentence test: "An app that [does this specific thing] for [this specific person]."

Rule 3: It should have one core interaction. What's the single most important thing your app does? A task manager: add and complete tasks. A quiz game: ask a question and check the answer. That core interaction is your whole first build.

12 great first project ideas

• A personal daily habit tracker with a simple checklist
• A quiz game on a topic you know well
• A simple word game (like Wordle, but on a theme you choose)
• A reading list tracker where you can add books and mark them as read
• A recipe collection where you can add, search, and view favourites
• A simple countdown timer with a custom message
• A basic expense tracker for a personal budget
• A flashcard app for learning vocabulary or facts
• A contact page or portfolio site for your own work
• A simple 'idea capture' tool where you can add and tag ideas
• A guessing game (number guessing, riddles, 20 questions)
• A daily journal with date-stamped entries

What to avoid first time

Don't build a social network. Don't build a marketplace. Don't build anything that requires real-money payment processing, user authentication at scale, or complex data relationships. These are all buildable eventually, they're just not where you want to start.

This is the article where everything comes together. We'll walk through a complete first build, from the initial idea to a working, shareable project. Follow along with your own idea or use the example throughout.

Step 1: Clarify your idea (10 minutes)

Before opening any tool, write down your answers to the four clarifying questions:

• What does it do? A trivia quiz where the player answers 5 questions from a chosen category.
• Who is it for? Anyone who wants a quick, fun quiz, mainly me.
• What does the main screen look like? A welcome screen with a category selector. Then one question at a time. Then a score screen at the end.
• What's the one most important thing? The question-and-answer flow must work perfectly.

Step 2: Write your first prompt

Take your answers and write a clear, specific paragraph:

Step 3: Review the first output

Open your tool, paste your prompt, and wait for the output. When it arrives, spend a full minute looking at it before typing anything. Check:

• Is the overall structure right? Three screens: welcome, quiz, score?
• Does the core interaction work? Can you click a question and see feedback?
• Is the design in the right direction?

Pick the single most important thing that's wrong and describe it specifically.

Step 4: Iterate toward the core working

Go back and forth on the core interaction until it works exactly the way you wanted. This may take 3-5 rounds. That's normal and expected. Don't add any new features during this phase, stay focused on making the essential thing work right.

Step 5: Add secondary elements

Once the question-and-answer flow is solid, you can add:

• More questions (ask the AI to add 10 more per category)
• Better visual feedback animations
• A progress indicator showing which question you're on
• Sound effects if you want them

Each of these is a separate request. One at a time. Check it works after each addition.

Step 6: Share it

Once you have something you're happy with, deploy it. In Bolt and Replit, deployment is one click. In Makermint, your project is shareable directly from your workspace. Share it. Show someone. Getting real feedback is enormously motivating.

What you've just done

You've gone from an idea to a working, live, shareable app. You've written a prompt, reviewed AI output, given specific feedback, iterated, added features, and deployed. That is the complete vibe coding workflow. Everything you build from here is a variation of this loop, applied to bigger and more complex ideas.