My Blog

The Rise of Vibe Coding

In early 2025, Andrej Karpathy coined the term "Vibe Coding." It wasn't just a meme; it was a recognition of a fundamental shift in how software is built. For decades, the barrier to entry for software engineering was syntax—knowing how to speak the machine's language, whether it was C++, Java, or TypeScript. You had to know where to put the semicolon, how to manage memory, and the specific invocation of an API.

Today, that barrier has dissolved. Vibe coding refers to the practice of writing code primarily through natural language prompts, relying on Large Language Models (LLMs) to handle the implementation details. You describe the vibe—the intent, the behavior, the outcome—and the AI handles the syntax. It's the transition from imperative programming ("do this, then do that") to declarative intent ("I want a system that does this").

But is this the end of the software engineer? Far from it. It is the evolution of the engineer into the architect, but this evolution comes with hidden costs and profound risks.

The Workflow Shift: From Construction to Curation

Traditionally, software engineering was an additive process: you faced a blank editor and added code line by line. In the Vibe Coding era, engineering has become a subtractive and sculptural process: the AI throws a block of code (raw material) at you, and your job is to chip away the excess and correct the textures.

This new workflow is not just a change in steps; it is a restructuring of cognitive patterns:

1. Structuring Intent (The New Pseudo-Code)

Previously, intent existed vaguely in the engineer's mind. Now, intent must be explicitly "serialized" into natural language.

The Vague Phase: "Write a user login function." -> The AI gives you generic code that likely violates your project's patterns.
The Structured Phase: "Use Next.js Server Actions for login. Database is Prisma, schema is in schema.prisma. Handle Zod validation and return structured error objects." -> This is effective Vibe Coding. Engineers must learn Prompt Engineering, which is effectively writing high-level pseudo-code. You are no longer coding in Python; you are coding in English, which is compiled into Python by the LLM.

2. Context Engineering

The AI is not omniscient; it doesn't know you refactored the utils folder last night. A core skill of the new workflow is Context Management.

You must decide which files to "feed" the AI. Feed too much, and it gets confused; feed too little, and it hallucinates.
It's like onboarding a brilliant but amnesiac contractor every single request. You must precisely tell them: "Look at this file, ignore that one, and follow the style of this existing module."

3. The Anchoring Bias Trap

This is the most dangerous phase. When an AI instantly generates 50 lines of code that looks logically sound, the human brain instinctively falls victim to Anchoring Bias.

We tend to accept the AI's solution as the "baseline" and only make minor tweaks, forgetting to ask: "Is this approach fundamentally wrong?"
Cognitive Slacking: Because the AI is perfect on 90% of the syntax, the reviewer's vigilance drops. Consequently, the critical 10% of errors—race conditions, security holes, or inefficient N+1 queries—slip into production under the guise of clean code.

4. Debugging Hallucinations

Traditional bugs are logical errors; you made a mistake. Vibe Coding bugs can be ontological errors.

The AI might call a library function that doesn't exist (because it saw something similar in 2021 training data, or it hallucinated a method based on the library's naming convention).
Debugging is no longer just checking StackOverflow; it's checking the official docs to verify, "Does this API actually exist?" This requires deeper fundamental knowledge to spot when the AI is confidently lying.

The Reviewer's Dilemma

When you write code line-by-line, you build a mental model of its execution. You know why a variable exists because you created it. When you generate code, you must reverse-engineer that mental model from the output.

AI-generated code often suffers from the "Illusion of Competence." It looks correct. It follows PEP-8 or ESLint rules perfectly. It has comments. But it might have a subtle logical flaw—an off-by-one error in a specific edge case, or a security vulnerability introduced by a hallucinated package version. Catching these bugs requires a higher level of seniority, not a lower one. You are no longer proofreading a junior developer's code; you are proofreading a savant who is confident but occasionally delusional.

The Epistemological Crisis: What is the Source of Truth?

Perhaps the most profound shift is philosophical. For 50 years, the "Source of Truth" was the source code. If you wanted to know how the system worked, you read the code. Documentation might be stale, comments might be lies, but the code was the truth.

In the Vibe Coding era, the source code is becoming a derivative artifact—compiled from natural language intent. This raises a dangerous question: If the code is generated and rarely read, is it still the source of truth?

We are moving towards a world where the Prompt and the Test Suite are the true assets. The code itself is just a transient intermediate representation (IR), much like Assembly language became after C was invented. We don't read Assembly anymore; soon, we might not read Python or TypeScript either.

Understanding Debt

This shift creates massive "Understanding Debt." Imagine a complex SQL query or a regex pattern generated by AI. It works. It passes the tests. But no human on the team actually understands how it works.

When that code inevitably breaks (due to a schema change or a new data pattern), who can fix it? If the original prompt is lost, or if the AI model has changed, regeneration might not produce the same result. We risk building systems that are "black boxes" to their own creators. We are no longer owners of the software; we are merely leasing functionality from a stochastic model.

The "Vibe Coding Hangover" and The Death of Apprenticeship

It's not all smooth sailing. The industry is currently grappling with the "Vibe Coding Hangover"—codebases built entirely by AI without sufficient human architectural oversight. These codebases are often bloated, inconsistent, and hard to maintain. But a deeper crisis looms: The Death of Apprenticeship.

The Loss of "The Struggle"

Senior engineers are senior because they spent years debugging trivial errors, writing boilerplate, and understanding low-level friction. They learned why npm install fails. They learned how memory leaks happen by causing them. They built their intuition through struggle.

Intuition is just crystallized pain.

If Vibe Coding removes the struggle, how will the next generation build intuition? If a junior engineer never has to write a CRUD API from scratch, will they understand how HTTP status codes actually work? We risk creating a generation of "Prompt Architects" who can describe a skyscraper but don't know that concrete needs time to cure.

The Pilot in the Simulator

The challenge for engineering leaders is no longer just shipping features, but artificially creating "gyms" where junior engineers can struggle safely. We might need to treat engineering training like pilot training. Pilots don't learn to handle engine failure by crashing real planes; they use simulators. We may need "Code Simulators" where juniors are forced to debug broken systems without AI assistance, just to build the muscle memory that Vibe Coding tries to bypass.

The New Core Competencies

If syntax is no longer the differentiator, what is? The skill tree for software engineers is being pruned and grafted.

System Design & Architecture: Understanding how components fit together is more important than knowing how to write a sorting algorithm. The ability to visualize data flow, consistency models, and fault tolerance is paramount.
Testing & Verification: Since generating code is cheap, the bottleneck moves to verifying correctness. Automated testing is no longer optional; it is the guardrail that makes Vibe Coding safe. The engineer's job is to write the tests that prove the AI isn't lying.
"AI Whispering" & Context Management: The ability to decompose complex problems into atomic, prompt-able tasks. It's not just about asking; it's about providing the right context (files, types, constraints) so the LLM has a fighting chance of success.
Debugging The Unknown: When the AI writes code using a library you've never seen, you need the fundamental CS knowledge to read the docs and debug it. Fundamentals matter more, not less.

Conclusion: The Steward of Complexity

Vibe Coding hasn't killed coding; it has elevated it. It has stripped away the repetitive drudgery of syntax and left us with the pure, distilled difficulty of problem-solving.

We are moving away from being bricklayers to being site managers. The tools are more powerful, but the responsibility to build something that stands the test of time—and the responsibility to understand how it stands—remains ours. The future engineer is a steward of complexity, orchestrating silicon intelligence to build human value.

Vibe Coding: The Shift from Syntax to Semantics