It’s a Vibe

So I thought I should put myself to the test, be a little Bayesian, build something basic, because it isn’t fair or professional to keep telling people that something isn’t as good as they are being told it is, without knowledge. So I paid for Copilot, and I dreamt up a project that I thought would be both simple and fun – and importantly that I knew I could build myself with relative ease.

Enter – Awesome Mixtape, just in time for Christmas!

The Good

Going from zero to one was astonishingly smooth. With a clear prompt or a rough markdown spec, Copilot can scaffold a Next.js + Tailwind app, complete with some auth flows, in half an hour. It tells you how to run it, how to see changes in real time, adjusts styles across breakpoints, and makes it fell like you are iterating at the speed of thought.

As someone who hates front-end work, I’ll admit: the speed was intoxicating. Copilot produced something cleaner than some early-stage teams manage in weeks.

We were on fire. Can you look up the Spotify API and create me a button that uses an OAuth flow to sign in with Spotify, tying a Spotify authentication token to a user in our database? Yes, I can, and here is how we’ll handle the JWT securely, including refresh flows. OK, neat, and actually, at this point, both the front end and server routes were pretty neat and well integrated. I need a database – yes, we recommend Supabase or AWS RDS, ahh but I do not want to introduce another third party, doesn’t Vercel have one? Turns out, yes actually, through 3rd parties which are phenomenally well integrated – I chose Neon, clicked a button and boom, even the env variables were updated…..

But hang on, I skipped ahead there didn’t I. To get to Vercel, I had to configure a Git repository, and give Vercel permission to deploy from it on push. Easy, if you know, and I had started from the repository. Env variables, what are they, don’t worry, I’ve created them for you, er, ok. Why isn’t it working when I publish it? OK, you need a little grounding in running a site but that isn’t so bad, you have to still do a little work yourself, but the speed gains are real. Change, test locally, dynamic reloads, beautiful, push, test on your server. I am an developer for sure! If you already understand how web apps hang together, Copilot feels magical.

OK, but

The honeymoon didn’t last long. A little, that was my fault, because I was allowed to go so fast, and because the tool get suggesting what I might like to do next, the scope crept. I went from super simple, to, just a little bit more, and hey, couldn’t we add a route for this, and yes I would like you to add that. A lot, it was Copilot’s fault. If you don’t care about code readability, hygiene or maintainability maybe you would not encounter these issues, but if you do things began to fairly rapidly deteriorate.

At this point, I’ll just resort to a list format otherwise, the prose will become too sprawling:

• Terrible modularisation
  Copilot happily duplicates components, logic, and types across files — each one slightly different. No shared components, no abstraction, no interfaces. It’s brittle chaos.
• Small changes sometimes trigger massive rewrites
  I’d ask for something tiny (“make the Share button green”) and Copilot would rewrite whole files for no reason. The button was green — but who knew what else changed?
• Looping into nonsense
  Sometimes it oscillated between introducing a bug and fixing that same bug repeatedly, burning tokens and producing surreal final code.
• JS/TS blind spots
  Tailwind config? globals.css? TypeScript quirks? It floundered constantly. I often had to spell out exact file locations and line numbers to get anything stable.
• Monorepo? Absolutely not
  I let it introduce a Solidity component. Suddenly dependencies exploded and context became incoherent. Even after reverting, it couldn’t “forget” the second project for half an hour.
• You still have to think
  Accessibility: surprisingly good.
  Semantic structure and SEO: atrocious.
  If you don’t know what good looks like, the AI won’t rescue you.
• Occasional hallucinations
  Sometimes it claimed to update a file… when nothing had changed.
• Inefficient logic
  It would use three queries where one would do. I lasted a while without editing the code manually, but sometimes I just couldn’t watch it suffer.
• Forgetting the To-Do list
  It kept a “To-Do list” only in spirit — mostly whatever we discussed in the last five minutes. A real living document must be explicit.
• Types? What types?
  Random anys, pointless | undefineds — despite having well-defined types available. Maddening.
• Everything else (still on you)
  OpenGraph, DNS, analytics, blob storage, email… Copilot can help, but only if you already know what needs doing.

The Ugly

Everything so far could be put down to both me wanting the moon on a stick *and* me not having worked out the best workflow with Copilot yet. If you wanted to get something simple out the door, you could get a surprisingly long way, with very little actual risk. But there were a couple of things that I think mean it is not ready for production, not just yet:

This is the part that makes me say: it’s not production-ready, not yet.

• It tempts you into endless scope creep
  Like ChatGPT, it’s socially engineered to keep you building. If you’re not extremely strict, your simple idea becomes a hydra. Operating at the speed of thought is one thing, but we were going faster, we were going at thoughtless speed!
• Over-engineering for no good reason
  It uses advanced TypeScript tricks, weird NPM scripts, and unnecessarily complex patterns. Results: unmaintainable code and confused AI.
• Security theatre
  Warnings like “don’t use this in production” don’t matter when vibe coders just copy-paste whatever works. Some code it wrote was flat-out insecure. Talking about copy-paste, there was an unusual trait where sometimes, most of the time, it would merrily update flies and then ocassinally it would ask permission to apply a patch, ok sure, go for it.
• API entropy
  Left to its own devices, Copilot keeps adding more fields, optional chaining, and random null-coalesced fallbacks. If you don’t define the API yourself, it will mutate into nonsense.

In conclusion

It feels pretty clear that within a few iterations and with more training data. it will get there. Copilot consumed an infinite number of tokens (I used latest Claude stable and Beta, latest Grok, GPT 5, Gemini 3 Pro) and produced a fair amount of nonsense on the journey, but it also enabled me to build far more in a single day than I ever could have without it.

Still, that speed wasn’t magic, it was me using every bit of my existing engineering experience to steer, correct, and occasionally rescue the thing. A less experienced developer would have hit a wall, or worse, produced something unmaintainable without realising it. And the irony is that while Copilot helped me build more, I could have built what I originally intended, the smaller, simpler version, faster and to a far higher standard on my own. It’s astonishing for prototyping, astonishing when you already know what you’re doing, and astonishingly dangerous if you don’t. This is just the beginning, though. You can feel how close we are to it becoming seriously good. Just… not yet.

What does my crystal ball say, strong Technical Product Managers have the edge, understanding how to build a Product that people need, and understand how the tech should work, powerplay! Engineers still trump Clippy, so keep hiring junior developers, and keep having that great software development lifecycle. Developers! make sure AI is in your armoury, but stay sharp, it isn’t a silver bullet, in fact, I think vibe coding may be the Mini Disc of the decade, lots of promise, loved by many, disappeared in history somewhere.

Now if you didn’t already – go check out Awesome Mixtape