Vibes died with xylophones

Vibe coding. Friends turning up in messages with whatever crap they'd told replit to build and how nobody needed coders anymore. Thanks guys.

They were right, in a sense. The same way nobody needed writers to write shitty SEO content about fixing washing machines after Dec 2022.

It was always loaded I thought, to conjure images of laid back flourish here and there throwing an app into play. I spent a lot of time being angry with them, perhaps because they were building that way.

And I'd continue typing my thirty years of experience into making machines work.

Then one day I hit a wall, and asked Codex at the time for some inspiration.

Mind blown.

Now a couple of years on I'll be the first to admit - I can go days without seeing code. I would check in now and again, but the new ease/speed of writing and automating unit tests made me much more comfortable than my own ability to read and check someone else's code.

SO - that lead me to the question - why care about styles and standards if, as is inevitable, AI will write AND review our code? Why force the machine to operate in the environment that we've carefully designed for humans to communicate to other humans through code?

Does it matter? Old school naming of variables and methods so perfectly that code documentation isn't needed. It seems quaint to think about in the face of "claude, explain this codebase to me".

But if we don't have standards and styles, the machine will take off on its own, inventing, hallucinating, going out of scope and worse. Won't it?

Perhaps. But not if we embrace standards based coding for machines. Explicit instruction as if we're instructing ok junior coders:

Never use lazy loading inside loops. Always eager load relationships explicitly using `with()` before iterating over a collection. 

Bad: 

$posts = Post::all(); foreach ($posts as $post) { echo $post->author->name; // triggers a query per post } 

Good: 

$posts = Post::with('author')->all(); foreach ($posts as $post) { echo $post->author->name; }

This quickly gets out of hand, and is eroded as a technique as the machines become better at "thinking". Explicit code instruction is giving way to minimal language suggestion, as we'd instruct a great junior coder. Andrej Karpathy's million star repo demonstrates with section 2:

**Minimum code that solves the problem. Nothing speculative.**

-   No features beyond what was asked.
-   No abstractions for single-use code.
-   No "flexibility" or "configurability" that wasn't requested.
-   No error handling for impossible scenarios.
-   If you write 200 lines and it could be 50, rewrite it.

Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.

It's genuinely a curious time where the pull of standards and rules is understandably strong, but the reality is - will we need them in a year's time? Or will they be as relevant as a manual explaining the inner workings of your toaster one day?