Programming used to be a world reserved for the technically trained. You’d learn syntax, data structures, and algorithms. You’d type line after line of code, debug errors, and slowly build up complex systems. That was the norm.
Over the past decade, though, tools started helping us more and more.
- Autocomplete and intelligent code editors helped fill in boilerplate.
- Code generators and low-code / no-code platforms let non-programmers build simple apps visually.
- Then large language models (LLMs) like GPT, Claude, and their variants got strong enough to generate nontrivial code from natural language.
In February 2025, Andrej Karpathy (who has a strong AI/ML profile) coined the term vibe coding. He described it as a style where you more or less “give yourself over to the vibes” — you prompt the AI with what you want, and (ideally) it just works, without you wrestling with every line of code.
Though Karpathy framed “vibe coding” in somewhat playful, exploratory terms, it rapidly became a touchpoint in tech conversations. It’s now seen by many as a possible turning point in how we build software.
Around the same time, research started exploring how AI-driven coding workflows transform roles, responsibilities, and risks. For instance, a recent qualitative study analyzed how developers feel about flow, trust, breakdowns, and collaboration when they use vibe coding. Another paper discussed how vibe coding shifts the distribution of “epistemic labor” — that is, who thinks and plans vs who implements.
So vibe coding is young. It’s experimental. But it’s growing fast, and many believe it points to a broader evolution in software creation.
What is vibe coding (in everyday terms)
Imagine you have an idea — say, “I want an app where I log daily habits, see a chart, and get reminders.” Instead of wiring up the UI, writing endpoints, handling database schemas by hand — you talk (or type) to an AI and describe what you want.
You’d say something like:
“Give me a simple web app using React and Node.js. It should let me add habits, mark them done, and plot completion over time. Store data in SQLite for now.”
The AI then produces the code — folder structure, components, backend routes, database schema, even some styling.
You run it. You find bugs or missing bits. You tell the AI “When I mark a habit done, don’t allow duplicate marks — validate that” or “Add a dark mode toggle.” The AI adjusts. You repeat until you have something usable.
That is vibe coding — your role becomes more of a designer, conversational partner, tester, and editor. The AI handles much of the low-level implementation.
In a stricter sense, “pure vibe coding” means you don’t even deeply inspect or understand most of the AI’s output. You lean on the AI instinctively. That kind of approach is risky for production—but it’s compelling for experimentation, prototyping, or personal projects.
In practice, most people will use a hybrid mode: you prompt, inspect, test, and refine. That hybrid form still counts as “vibe coding” in the broader sense. And as of recently, more people are learning about AGENTS.md – a special file that can be created to give the AI more clear and defined instructions on how it should vibe code.
The promise and the challenges
Vibe coding is appealing. But it’s not magic. Let me lay out the good side and warning signs.
What’s attractive about vibe coding
- Speed and prototyping: You can go from idea to working app sometimes in minutes or hours, not days.
- Accessibility: People without formal programming training can build simple tools or prototypes just by describing what they want.
- Less boilerplate drudgery: The AI handles repetitive scaffolding, wiring, routing, etc., letting you focus on features and logic.
- Creative exploration: Because iteration is cheap, you can try ideas you might never build manually.
What you need to watch out for
- Black box code: It may generate something you don’t fully understand. If you or others must maintain it later, that becomes painful and/or time-consuming.
- Bugs, security holes, inefficiency: The AI may introduce subtle errors or assumptions that don’t scale.
- Drift from best practices: Generated code might not follow clean architecture or long-term maintainability.
- Collaboration & handoff issues: If a team member didn’t write the code, they may struggle to trust or extend it.
- Tool limitations: The AI may “hallucinate” — fabricate logic or rely on outdated libraries.
- Overreliance on AI: If the AI fails (or goes offline, or changes), you might not know how to finish or fix things.
Research points to a “continuum” of trust: some developers fully delegate small parts to the AI; others treat it as a stricter collaborator. The more you trust it, the more “vibe” you lean into — but also the more risk you carry.
Vibe coding reconfigures intent mediation: you’re not specifying exact steps anymore — you’re instructing goals and letting the system infer implementation. That shift changes what humans vs machines are responsible for.
So vibe coding is powerful — but also delicate. You need to treat it like working with a smart but imperfect partner, not a perfect oracle.
How you can try vibe coding today
If you’re reading this, you might want to see “vibe coding in action.” Here’s a realistic starter path.
1. Choose a platform or AI tool
You don’t need special hardware. Just pick an AI or platform that supports code generation.
Options include:
- General language models like ChatGPT (with code capabilities), Claude, GPT-5, Gemini, etc.
- Tools that integrate coding agents (Cursor Composer, Replit’s AI tools)
- Cloud or IDE plugins that embed AI as a development assistant.
Pick one you can access easily and affordably.
2. Start with a small project
Don’t begin by trying to build an enterprise app. Choose something simple:
- A to-do list app
- A habit tracker
- A basic blog engine
- A weather dashboard
The goal is to experience the loop: prompt → generate → run → inspect → refine.
3. Craft your first prompt
Be clear. Describe:
- The languages or frameworks you want
- The features you expect
- How data should be stored
- Any constraints or style preferences
Example prompt:
Create a simple web app using React for the frontend and Node.js + Express for the backend. It should let users register, log in, and save notes. Use MongoDB for storage (local for now). Include basic error handling and input validation.4. Run it, test it, and iteratively improve
You’ll see errors or missing parts. You might ask:
- “When the user logs in, if the password is wrong, return a JSON error message.”
- “Add pagination to note list if there are too many.”
- “Make the UI mobile responsive.”
Each time, treat the AI as a collaborator. Use tests, logs, debugging to spot failures.
5. Ask the AI to explain code
If part of what it generated doesn’t make sense, you can prompt:
“Explain this function line by line, and suggest improvements.”
That helps you learn and ensures you’re not blindly accepting everything.
6. Refactor and clean up
Once it works, tidy the code, rename variables, reorganize folder structure, remove redundant bits. You can even prompt:
“Refactor my code to use MVC architecture. Break out services and controllers.”
This helps you shape the generated code into something maintainable.
7. Gradually increase complexity
After you’re comfortable, try adding:
- Authentication via OAuth
- State management (Redux, Context)
- Integration with external APIs
- Deployment (DigitalOcean, Vercel, etc.)
- Tests (unit, integration)
Always keep going back to prompt → generate → test → refine.
How to think about vibe coding going forward
This new paradigm is reshaping how we think about programming. It’s not about replacing developers — it’s about shifting which skills are critical.
- Prompt engineering becomes a core craft: learning how to express intentions so the AI responds usefully.
- Understanding architecture, design, data modeling, error handling becomes more important relative to memorizing syntax.
- The human’s role becomes more about oversight, quality, context, and orchestration.
In that sense, vibe coding is as much a mindset shift as a tool shift. It’s a way of interacting with AI to bring ideas into code faster — but you still bring the judgment and responsibility.
