I do think we need a new definition for vibe-coding, because the way the term is used today shouldn’t necessarily include “not even reading the code”.
I’m aware that Karpathy’s original post included that idea, but I think we now have two options: - Let the term vibe-coding evolve to cover both those who read the code and those who don’t. - Or define a new term — something that also reflects production-grade coding where you actually read the code. If that’s not vibe-coding, then what is it? (To me, it still feels different from traditional coding.)
I have a few problems with evolving "vibe coding" to mean "any use of LLMs to help write code:
1. Increasingly, that's just coding. In a year or so I'll be surprised if there are still a large portion of developers who don't have any LLM involvement in their work - that would be like developers today who refuse to use Google or find useful snippets on Stack Overflow.
2. "Vibe coding" already carries somewhat negative connotations. I don't want those negative vibes to be associated with perfectly responsible uses of LLMs to help write code.
3. We really need a term that means "using prompting to write unreviewed code" or "people who don't know how to code who are using LLMs to produce code". We have those terms today - "vibe coding" and "vibe coders"! It's useful to be able to say "I just vibe-coded this prototype" and mean "I got it working but didn't look at the code" - or "they vibe-coded it" as a warning that a product might not be reviewed and secure.
Just like no one speaks of vibe-aeronautics-engineering when they’re “just” using CAD.
More specifically, GAIA in SDE produces code systematically with human in the loop to systematically ensure correctness. e.g. Like the systematic way tptacek has been describing recently [2].
[1] https://en.m.wikipedia.org/wiki/Gaia
[2] https://news.ycombinator.com/item?id=44163063
Briefly summarized here I guess: https://news.ycombinator.com/item?id=44296550
Blind-coding.
Nice blog by the way, I love the design. I have a similar website: https://www.murhabazi.com/ and I love to grab some components from yours.
I have checked the site is not public, if it doesn't have private data, can you make it public so that we can copy its design?
If that is not possible, can you add you give me view access? My username is EspoirMur
My wife used the $20 claude.ai and Claude Code (the latter at my prompting) to vibe-code an educational game to help our five-year-old with phonics and basic math.
She noticed that she was constantly hitting token limits and that tweaking or adding new functionality was difficult. She realized that everything was in index.html, and she scrolled through it, and it was clear to her that there was a bunch of duplicated functionality.
So she embarked on a quest to refactor the application, move stuff from code to config, standardize where the code looks for assets, etc. She did all this successfully - she's not hitting token limits anymore and adding new features seems to go more smoothly - without ever knowing a lick of JS.
She's a UX consultant so she has lots of coding-adjacent skills, and talks to developers enough that she understands the code / content division well.
What would you call what she's doing (she still calls it vibe coding)?
But I think the fact that she's managing without even knowing (or caring to know) the language the code base is written in means that it isn't really "coding" either.
She's doing the application architecture herself without really needing to know how to program.
I've copy-pasted snippets for tools and languages that I do not know. Refactored a few parameters, got things working. I think that counts as programming in a loose sense. Maybe not software development or engineering, but programming.
The first non-toy program I ever wrote was in BASIC, on ZX Spectrum 48, and although I don't have it anymore, I remember it was one of the shittiest, most atrocious examples of spaghetti code that I've ever seen in my life.
Everyone starts somewhere.
I was picking apart other peoples' javascript to see how it worked years before I was taught anything about coding in a formal setting.
Also I feel old now, I think we _just_ did XP at a company, but that was almost a quarter century ago :D
This didn't really work - it would often implement a factored-out piece of logic but just leave the pre-existing code alone. So she had to be pretty specific about problem areas in order to actually push the refactoring plan forward.
I think orchestration may be a step that can't really be magicked away by advancements, beyond toy implementations. Because at the end of the day it is just adding specific details to the idea. Sure, you can YOLO an idea and the LLMs can get better at magically cleaning things up, but the deeper you go the larger the drift will be from the concept and the reality without continued guidance.
If LLMs could construct buildings you might describe what you want room by room and the underlying structure will need to be heavily revamped at each addition. Unless you start with "I am making a 20 floor building" you are going to waste a lot of time having the LLM re-architect.
I think the real new skill people are going to get scary good at is rapid architecting without any strong awareness of how things work underneath the hood. This is the new "web programming isn't real programming" moment where future developers might not ever look at (or bother learning about!) variables or functions.
So, clearly, almost nobody does that anymore. So according to Karpathy's definition, we have all been vibe coding for quite time now. (An aside - if AIs were any good, they would just skip human languages entirely and go straight to binary.)
So I think the "vibe" in vibe coding refers to inputting a fuzzy/uncertain/unclear/incomplete specification to a computer, where the computer will fill in details using an algorithm which in itself is incomprehensible for humans (so they can only "feel the vibes").
Personally, I don't find the fuzziness of the specification to be the problem; on some level it might be desirable, having a programming tool like that. But the unpredictability of the output is IMHO a real issue.
Because the compiler is deterministic and the cost of getting something better (based on the processor capability) is higher than just going with the compiled version, which has like 99.9% chance of being correct (compiler bugs are rare). It's not vibecoding. It's knowing your axioms is correct, when viewing the programming language as a proof system (which it is). You go from some low level semantics, upon which you build higher level semantics which forms your business rules.
So giving the LLM a fuzzy specs is hoping that the stars will align and your ancestors spirits awaken to hear your prayers to get a sensible output.
And I agree with the logic part too. I think we could have humans input fuzzy specification in some formal logic that allows for different interpretations, like fuzzy logic or various modal logics or a combination of them. But then you have a defined and understandable set of rules of how to resolve what would be the contradictions in classical logic.
The problem with LLMs is they are using a completely unknown logic system, which can shift wildly from version to version, and is not even guaranteed to be consistent. They're the opposite of where the software engineering, as an engineering discipline, should be going - to formalize the production process more, so it can be more rigorously studied and easier to reproduce.
I think what SW engineering needs is more metaprogramming. (What we typically call metaprogramming - macros - is just a tip of the iceberg.) What I mean is making more programs that study, modify and transform the resulting programs in a certain way. Most of our commonly used tools are woefully incapable of metaprogramming. But LLMs are decent at it, that's why they're so interesting.
For example, we don't publish version modifications to language runtimes as programs. We could have, for example, produce a program that would automatically transform your code to a new version of the programming language. But we don't do that. It is mostly because we have really just started to formalize mathematics, and it will take some time until we completely logically formalize all the legacy computer systems we have. Then we will be able to prove, for instance, that a certain program can transform a program from one programming runtime to another at a certain maximal incurred extra execution cost.
It's not unknown. And it's not a logic system. Roughly, it takes your prompt, add it to the system prompts, runs it trough a generative program that pattern-match it to an output. It's like saying your MP3 player (+ your mp3 files) is a logic system. It's just data and it's translator. And having a lot of storage to have all the sounds in the world just means you have all the sounds in the world, not that it's automatically a compositor.
And consistency is the basic condition for formalism. You don't change your axioms, nor your rules, so that everyone can understand whatever you said was what you intended to say.
> What I mean is making more programs that study, modify and transform the resulting programs in a certain way.
That certain way is usually fully defined and spec-ed out (again, formalism). It's not about programming roulette, even if the choices are mostly common patterns. Even casinos don't want their software to be unpredictable.
> Most of our commonly used tools are woefully incapable of metaprogramming.
Because no one wants it. Lisp has been there for ages and only macros have seen extensive use, and mostly as a way to cut down on typing. Almost no one has the needs to alter the basic foundation of the language to implement a new system (CLOS is kinda the exception there). It's a lot of work to be consistent, and if the existing system is good enough, you just go with it.
> we don't publish version modifications to language runtimes as programs
Because patching binary is harzadous, and loading programs at runtime (plugins) is nerfed on purpose. Not because we can't. It's a very big can of worms (we've just seen the crowdstrike incident when you're not careful about it).
Reminds me of Steve Yegge's short-lived CHOP - Chat Oriented Programming: https://sourcegraph.com/blog/chat-oriented-programming-in-ac...
I remain a Karpathy originalist: I still define vibe coding as where you don't care about the code being produced at all. The moment you start reviewing the code you're not vibe coding any more, by the definition I like.