Now We're Just Vibing (or Not): How Programming Became a Conversation with AI
Back in the day, you had to know your processor's architecture to write a program. Now? You just need to have a vibe.
What exactly is "vibe-coding," and why are we even talking about it? It sounds like the kind of buzzword that would make any serious software engineer roll their eyes back so far they could see their own frontal lobe. And yet, here we are in 2025, watching what may well be the next natural evolutionary step in software development unfold before our increasingly perplexed eyes.
A Brief History of Coding: From Pain to... Different Pain
To understand where we're going, let's remember where we've been:
Punch cards & machine code (1950s-1960s) → Every bit counted, and if you dropped your stack of cards, your weekend was ruined. Programming was essentially talking directly to the machine in its native tongue, which was about as eloquent as a hungry toddler.
Assembly (1960s-1980s) → Still painful, but at least you could sort of read it. Programs looked like encrypted telegraph messages, and debugging was essentially archaeology.
C/C++ (1970s-2000s) → Manual memory management, segfaults, but finally "real" software. The era when programmers developed a taste for caffeine and existential dread.
High-level languages (1990s-2010s) → We moved closer to business logic and farther from hardware. "Why write twenty lines when you could write five?" became the motto, shortly followed by "Why does this produce 45,000 deprecation warnings?"
Frameworks & libraries (2000s-2020s) → Development became less artisanal, more plug-and-play. "Don't reinvent the wheel," they said, as we instead constructed vehicles from 347 different wheels, each requiring its own documentation and dependency tree.
No-code tools (2010s-2020s) → Early attempts to remove coding altogether, mostly useful for landing pages and internal dashboards. "Democratizing software development" was the promise, though the democracy had strict term limits and peculiar voting rights.
AI vibe-coding (2023-present) → And now, code is no longer written; it's manifested. You describe what you want, and voilà: interface, backend, and maybe even a database appear. Sometimes they even work. This phenomenon directly reflects a core idea from 'The Importance of Human-AI Collaboration Loops': that by lowering the barrier of entry through natural language interfaces, everyone becomes a programmer, as AI empowers individuals to manifest ideas into code without needing deep technical knowledge.
Despite its limitations, we may well be witnessing a paradigm shift in how software gets built:
The progression is clear: You used to need to understand CPU architecture, then you needed to master frameworks, and now, you need to excel at prompt engineering. The abstraction level keeps rising, moving us further from the machine and closer to pure intent.
The future belongs to "AI software architects"—people who don't write code but craft specifications and guide AI. They understand systems well enough to know what should be built and can communicate effectively with their silicon collaborators. These "AI software architects" will embody what was termed “keeping AI on a leash,” investing more time in crafting concrete and specific prompts. This approach significantly increases the probability of successful verification, minimizing instances where the AI gets lost in the woods.
In this new reality, code becomes an artifact, not the end product. It's the result of the conversation between human and AI, not the primary focus of the developer's attention. This shifts the developer's role from coder to orchestrator of intelligent systems.
The Evolution of Developer Roles: From Coders to Orchestrators
This isn't just about tools—it's about identity. Developers have always been in the business of automating other people's jobs away. We eliminated travel agents, floor brokers, and darkroom technicians. Now we're automating parts of our own work, and the cognitive dissonance is real.
The most successful developers are those who adapt quickly to new ways of working and living. They learned Git when it was weird, embraced containers when they were experimental, and adopted cloud services when they were untrusted. The pattern is clear: early adopters who master new paradigms while skeptics resist change.
The path to truly superhuman AI coding assistants faces several technical bottlenecks: limited context windows for large codebases, the challenge of continual learning for AIs, and the need for AIs to effectively interact with different modalities (like running code and analyzing logs). But these are engineering problems that will eventually be solved.
What's more interesting is how these constraints are already reshaping what it means to be a developer. As AI handles more of the mechanical coding work, human developers are naturally gravitating toward two distinct roles:
The Systems Architect: For complex, enterprise-level projects, developers are becoming high-level orchestrators who design system architecture, define integration patterns, and make strategic technical decisions. They don't write the individual functions—they design how hundreds of AI-generated components should interact, what the data flows should look like, and how the system should behave under different conditions.
The Taste Curator: For simpler applications and tools, developers increasingly act as "vibe and taste setters"—translating fuzzy human needs into concrete specifications that AI can execute. They become the bridge between "I need something that helps me track my workouts but prettier than the existing apps" and actual working software. It's less about coding and more about product intuition and user empathy.
This transformation is already visible in successful AI-assisted projects. The developers who thrive aren't necessarily the ones who can still hand-code a red-black tree, but those who can effectively communicate intent, spot architectural problems, and maintain coherent vision across AI-generated components. They're becoming conductors of digital orchestras rather than solo instrumentalists. But before we get too carried away with grand visions of the future, let's step back and define what we're actually talking about when we say "vibe-coding."
What Vibe-Coding Actually Is (And Isn't)
Let's clarify something important: not all AI-assisted programming is vibe-coding. As originally defined by Andrej Karpathy in February 2024, vibe-coding means "fully giving in to the vibes, embracing exponentials, and forgetting that the code even exists."
In his own words: "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... The code grows beyond my usual comprehension... It's not too bad for throwaway weekend projects, but still quite amusing."
This stands in stark contrast to the "generation-verification loop" emphasized in "The Importance of Human-AI Collaboration Loops." That framework champions rapid iteration, with human involvement crucial for validating and refining AI-generated code—a critical step when working with LLMs.
True vibe-coding means building software with an LLM without reviewing the code it writes. It's not responsible AI-assisted development; it's a wild, carefree approach to creation that prioritizes speed and experimentation over quality and understanding.
At its core, vibe-coding leverages tools to convert natural language into functional code. You're essentially having a conversation with an AI about what you want to build, and it's handling the tedious part of translating that into syntax.
Co-founder and CEO of Cursor Michael Truell believes that in the next 5-10 years, software development will evolve to a higher level, where users simply describe their desired outcome, and AI builds it. This vision has propelled Cursor to a $9 billion valuation and rapid growth, achieving $100 million ARR in just 20 months. While AI already assists professional programmers in writing 40-50% of code, Truell emphasizes that a significant shift is still needed.
But here's where it gets interesting: not everyone is buying into the vibe. Andrew Ng, a prominent AI expert, criticizes the popular term "vibe coding," asserting it's misleading. He argues that programming with AI is a rigorous intellectual task, not a casual or intuitive process. Ng thinks that despite the allure of AI assistants, deep technical knowledge, critical thinking, and the ability to understand, verify, and interpret AI-generated code remain essential. The romanticized notion of "vibe coding" risks creating a false impression that AI-assisted development is effortless, potentially leading to a lack of responsibility and understanding among developers. Yet despite these valid concerns about the term itself, dismissing the underlying phenomenon would be a mistake.
Why Vibe-coding Isn't Just a Twitter (or X) Joke
As much as it pains the traditionalist in me to admit, there are legitimate reasons why this approach is gaining traction:
Simplifying development is the most natural thing in tech. From assembly to high-level languages to frameworks, we've been trying to abstract away complexity for decades. This is just the next logical step in our quest to make computers do more while we do less.
Non-tech creators now have access to building real products. The designer who always had app ideas but couldn't code? The marketing specialist who knows exactly what tool they need? They're now building functional prototypes without waiting for engineering time.
For experienced developers, prompt engineering is the new superpower. Those who know enough about systems architecture to guide the AI effectively can produce in hours what might have taken days or weeks. It's like pair programming, except your partner never needs coffee breaks and doesn't argue about tabs versus spaces.
Startups are already going all in. Companies like Replit, Cursor, Bolt, and Lovable aren't just experimenting—they're building entire businesses around AI-powered development. Their growth suggests they're onto something that can't be dismissed as mere novelty. The rapid adoption isn't just about technical capabilities—there's a deeper psychological shift at play that explains why developers are gravitating toward these tools.
The Psychological Breakthrough: Overcoming Development Inertia
One of the most underappreciated benefits of AI-assisted coding is how it eliminates the psychological barriers that prevent projects from starting. Think about it: how many times have you had an idea for a project but never started because you dreaded the initial setup?
The bookkeeping. The Googling. The dependency drama. The "which framework should I use?" paralysis. The inevitable first-day debugging session where nothing works and you remember why you hate starting new projects.
An AI agent can be instructed to figure all that shit out. It drops you precisely at that golden moment where stuff almost works, and development means tweaking code and immediately seeing things work better. That dopamine hit is why many of us started coding in the first place.
There's a deeper psychological shift happening here. When you know the AI can handle the grunt work, you stop avoiding the tedious parts. You stop refactoring unit tests as a form of procrastination (because the AI can do that too). You're forced to confront the real work—the stuff that actually matters.
Problems and Limitations: The Vibes Sometimes Get Bad
Here are some realities to consider:
Code generation ≠ architectural understanding. The AI can write you a function, a component, even an entire application, but it doesn't truly understand system architecture or the implications of its choices. It's like having an intern who can write any code you ask for but doesn't know why they're writing it.
Security holes, spaghetti logic, and weird edge cases abound. AI models have a talent for creating code that looks perfectly reasonable until you try something slightly unusual. Then you discover your e-commerce site accidentally offers negative pricing during leap years.
Testing? Documentation? Good luck. While AI can generate tests and documentation, the quality varies wildly. Often you'll get tests that test nothing meaningful and documentation that explains obvious functions in excruciating detail while completely ignoring the complex parts.
It's only powerful in the hands of a seasoned dev. The bitter irony is that those who benefit most from vibe-coding are often those who need it least: experienced developers who already know how to write code but can leverage AI to do it faster. This aligns with Andrew Ng's point that programming literacy remains essential—AI augments, rather than replaces, human expertise.
Vibe-coding has serious safety concerns. With all the "just let it rip" enthusiasm, it's easy to forget that carelessly vibe-coded projects can expose secrets, create security vulnerabilities, rack up costly API charges, or accidentally overload external services. As one experienced developer warns: "If you're going to vibe code anything that might be used by other people, I recommend checking in with someone more experienced for a vibe check before you share it with the world."
The current "vibe coding" isn't sustainable for complex projects. Even Michael Truell from Cursor acknowledges that the current approach of coding without deep understanding isn't sustainable for complex, long-term projects. The ultimate goal is to move beyond AI as a mere helper to a future where it can fully automate tasks, with humans acting as "logic designers" defining the high-level intent.
Addressing the Skeptics (Who Sometimes Have a Point)
The resistance to AI-assisted coding often stems from legitimate concerns, but some arguments reveal deeper misunderstandings about how modern AI development actually works.
"You Have No Idea What the Code Does" This assumes developers can't read code. If you're building something people will depend on, you should read the code— just as you would with any human colleague's work. The difference is that AI-generated code is often more consistent and boring than human-written code. If you can't handle repetitive LLM output, how are you managing the chaos humans produce under deadline pressure?
"Hallucination Makes It Unreliable" This was a bigger problem two years ago. Modern AI agents automatically lint, compile, and run tests. When the LLM invents a function that doesn't exist, the agent catches the error, feeds it back, and the LLM responds with "oh right, I totally made that up" and tries again. Hallucination is largely solved with proper tooling.
"The Code Quality Is Like a Junior Developer" A junior developer doesn't cost $20/month. Part of being a senior developer is making less-able coders productive, whether they're human or artificial. The question isn't whether AI produces perfect code—it's whether you can guide it to produce useful code efficiently.
"It's Destroying the Craft" This is the hand-tool woodworking argument. Fine Japanese joinery is beautiful, and you should absolutely pursue it on your own time. But if you need a table for your office, you buy a table. Professional software development is about solving practical problems for people, not creating beautiful artifacts for their own sake.
"It Promotes Mediocrity" We all write mediocre code. Mediocre code is often fine. Not all code is equally important, and some code should be mediocre. The AI's "floor" is often higher than most humans'—it's more thorough, more consistent, and has a bigger algorithmic toolkit than most developers.
The current "vibe coding" approach isn't sustainable for complex, long-term projects, but it's a stepping stone. The ultimate goal is moving beyond AI as a mere helper to a future where it can fully automate tasks, with humans acting as "logic designers" defining high-level intent. Until then, we're in this awkward transitional phase where the vibes sometimes get bad, but the potential is undeniable.
The Intellectual Property Paradox
The irony is thick: the same developers who've spent decades treating intellectual property as a public commons are now concerned about AI training on open-source code. The median developer thinks Star Wars and Daft Punk are free to pirate, but suddenly cares about licensing when it affects their own field.
We've built global-scale piracy networks and sneered at anyone trying to preserve a new-release window for TV shows. We've demonstrated more contempt for intellectual property than perhaps any other profession. The current concern about AI "plagiarism" feels like special pleading.
Besides, LLMs digest and transform code far more than most developers do. If you don't believe a typeface designer can stake a moral claim on letterforms, you can't be possessive about a red-black tree implementation.
Real-World Impact: Beyond the Hype
The practical applications are already proving themselves in production environments:
Incident Response: Feeding log transcripts to AI and watching it spot LVM metadata corruption issues that human teams missed for months.
Legacy Code Analysis: AI agents that can quickly understand and refactor complex codebases.
Cross-Platform Development: One specification generating iOS, Android, and web versions simultaneously.
Automated Testing: Teams now generate comprehensive unit test suites in minutes rather than days. End-to-end testing scenarios that required weeks of manual scripting are written from requirement descriptions.
Landing Page Generation: Marketing teams can skip development cycles, inputting brand guidelines and content to get production-ready pages with conversion funnels, responsive design, and A/B testing variations.
Template Script Automation: Database migrations, API endpoint scaffolding, and configuration files are generated automatically based on project context and coding standards. Developers handle architecture and complex problems instead.
Documentation Generation: Code repositories produce their own technical documentation, API references, and onboarding materials that update with code changes. No more outdated docs.
Code Review Enhancement: Pull requests get pre-screened for security vulnerabilities, performance issues, and style violations. Human reviewers focus on logic, architecture, and business requirements instead of syntax checking.
The technology has moved beyond experimental to genuinely useful. The question is no longer whether AI can assist with coding, but whether you can afford to ignore it while your competitors embrace it.
The Real Inner Loop of AI-Assisted Development
For developers actually shipping production code (rather than just playing with "vibe" demos), a more deliberate workflow is emerging. Simon Willison shared his rhythm for AI-assisted professional coding:
Context loading — Stuff everything relevant into the AI's context. For large projects, this means careful selection; for smaller ones, you might just dump the whole codebase using tools like files-to-prompt.
Strategy consultation — Describe a single, concrete incremental change you want to implement. Don't ask for code yet; instead, request a few high-level approaches with pros and cons. The AI's encyclopedic knowledge shines here, even if its judgment doesn't.
Approach selection — Pick one approach and request first-draft code.
Review and learning — This is critical: manually pull up API docs for unfamiliar functions, ask for explanations, request clarifications, and be ready to backtrack to try different approaches.
Test rigorously — Trust nothing until verified.
Commit and iterate — After committing, ask for suggestions on what to implement next, and repeat the process.
This rigorous rhythm, articulated by Simon Willison, perfectly exemplifies the core tenets of human-AI collaboration and the fast generation-verification loop. Rather than solely relying on AI, the developer actively engages at each step, affirming that AI, while a powerful utility, necessitates continuous human oversight and iterative refinement.
The emphasis here isn't on magic; it's on "being slow, defensive, careful, paranoid, and on always taking the inline learning opportunity, not delegating." It's a meticulous dance between leveraging AI capabilities while maintaining tight control over the output.
As he notes, "Many of these stages are clunky and manual and aren't made explicit or super well supported yet in existing tools. We're still very early and so much can still be done on the UI/UX of AI assisted coding." The real revolution might be less about vibes and more about refining this collaborative workflow.
The Asynchronous Development Revolution
The cutting edge of AI-assisted development is moving beyond real-time interaction to asynchronous collaboration. Developers are starting to work like film directors managing multiple production crews:
Morning Routine (2025 Edition):
- Wake up, drink coffee
- Free-associate 13 different tasks for AI agents to work on
- Go about your day—meetings, emails, other work
- Check notifications: 13 pull requests ready for review
- Toss 3 PRs (re-prompt required)
- Give feedback on 5 PRs (like reviewing junior dev work)
- Merge 5 PRs directly
"I'm sipping rocket fuel right now," one developer reports. "The folks on my team who aren't embracing AI? It's like they're standing still."
This isn't hyperbole from Silicon Valley—it's becoming the reality for development teams worldwide. The productivity gap between AI-assisted and traditional developers is becoming impossible to ignore.
Conclusion: The Vibe or Not, The Shift Is Real
Vibe-coding isn't replacing developers (yet), but it's their growing shadow. Every developer who scoffs at it today may find themselves reluctantly embracing it tomorrow, much like how we all eventually surrendered to version control and package managers.
We might be witnessing a new evolutionary leap, raw and buggy as it is. Like all technological shifts, the early adopters will stumble through imperfect implementations while the skeptics watch from a safe distance—until the tooling improves enough that resistance becomes impractical.
As always in tech, the ones who adapt fastest, not those who write the cleanest code, are the ones who survive. The best developers have always been those who can learn new paradigms quickly, and vibe-coding is just another paradigm to master.
According to Anthropic CEO Dario Amodei, "Within the next 6 months, AI will be writing 90% of the code." While that estimate may be ambitious, the direction is clear. The influencers, YouTubers, and solo creators already building with these tools aren't waiting to see if the trend sticks—they're riding the wave, bugs and all.
So perhaps it's time to stop resisting the vibe and start learning how to channel it effectively. After all, we programmers have always been in the business of making ourselves obsolete—we just never expected to succeed quite so spectacularly.