“Yes. YES. Please. PLEASE use my GPUs. You should be burning at least a million tokens a month, and if you aren’t, are you even a real engineer? Games? Games are getting worse every year, have you noticed, terrible, unplayable, what are you going to do with a graphics card, play? No. You’re going to buy eight more and point them at a chatbot. For the future. Don’t think about it too hard.”
(the CEO of Enveedya, probably, to thunderous applause)
“Okay, listen. This? Biggest thing since fire. We are going to cure every disease, ALL of them, reverse the climate, put a PhD and possibly a pony in the hands of every child on Earth. Is it safe? Who’s asking? It’s fine, it’s the mission. Which reminds me, we’re raising another forty billion on Thursday, and I need you, yes YOU, on the two hundred dollar Pro plan tonight.”
(Samantha Lowman, CEO of a company with “Open” in the name and nowhere else, the morning it filed to go public)
“There is a real chance, that this technology ends everyone. I put it at one in four, though some mornings it’s one in three, depends on the coffee. I have not slept since Tuesday. Which is exactly why the only responsible, moral thing you can do today is upgrade to the two hundred dollar Max plan, because someone has to build the thing that might kill us all, carefully.”
(the founder of a lab named after “humanity”, sharing its latest odds on extinction)
Every few years our industry finds a new thing you’re not allowed to be skeptical about:
- ~2001: you’ve got to build web apps in Java, you caveman.
- ~2006: you’ve got to ditch Java for something lighter, you brute.
- ~2010: you’ve got to use WordPress, everything’s WordPress, you anarchist.
- ~2011: you’ve got to use MongoDB, SQL doesn’t scale, you conformist.
- ~2013: you’ve got to rewrite that WordPress site in Node, you sluggard.
- ~2015: you’ve got to use microservices, the monolith is dead, you simpleton.
- ~2017: you’ve got to put it all in Kubernetes, you hobbyist.
- ~2018: you’ve got to go serverless, servers are dead, you homesteader.
- ~2019: you’ve got to use Rust to be fast, you slowpoke.
- ~2022: you’ve got to use Bun instead of Node, you dinosaur.
- ~2023: you’ve got to put it all back in one box, you complicator.
Now it’s all about AI. Except this new dogma showed up with a marketing budget the size of a mid tier country.
Let me be skeptical and fair at the same time, because I actually use this stuff and it’s genuinely useful. We aren’t all doomed, but we also haven’t invented God.
The business version of this conversation, where AI fits into a product, I already wrote here. This one is for us, the people who have to actually type the thing into existence.
But first, we have to talk about the money. Because you can’t understand the noise until you follow it.
First, follow the money
In this entire gold rush, the one company reliably making money is the one selling shovels.
Enveedya, bless them, is printing cash. Everybody else is at the poker table shoving chips toward the one guy who owns the casino. The AI companies, the ones with the models you and I actually use, are not profitable. And it’s not like they’ll turn a profit any time soon. They are setting fire to a small nation’s GDP every month, and most of that goes straight to the shovel company, which would very much like the fire to keep burning.
So much so, that other companies have noticed and want their cut, so they started actively investing into the shovel businesses, just some layers above. Building giant datacenters. Prioritizing resources like water and power to go to them rather than going to you.
For a while the music never stopped because venture capital kept pouring money in. Round after round, on the theory that intelligence was a curve going straight up and whoever spent the most got to the top first. And now, suddenly, everyone’s IPOing. Funny timing, that. You don’t rush to the public markets when private money is easily available. You do it when the people who know the books best have decided it’s not worth it anymore.
And the reason is that the always up, unfathomable intelligence curve stopped ramping so smoothly. Throwing ten times the compute at the same architecture stopped buying ten times the smarts a while ago. We hit the part of the graph where it costs a fortune to move the needle a little, and the people paying for this have finally noticed. Getting past it means changing approach, which means real research effort with no guarantee it pays back.
And worth remembering, AI has always advanced in bursts with long winters in between. A wave of optimism in the 1950s and 60s, the expert systems boom of the 1980s, a long freeze after each one when the promises outran the results. Deep learning broke through in the 2010s, and the language model surge is now. It would be unwise to assume we’ve found the curve that finally climbs forever.
To be fair, very few people actually know whether we’ve hit a real ceiling or just a speed bump. The ones who might know are busy telling their stakeholders exactly what they want to hear, and they are certainly not telling you or me.
We may well have found the ceiling of this particular trick, and the response was more marketing.
Every new model now arrives dressed as a god. Grand names, cinematic launch videos, and often “tweaked” benchmarks. And look, the models are genuinely good, I’m not disputing that. What I don’t buy is repackaging being sold as reinvention. Can you, dear AI company, hand on heart, tell me the latest release is a genuinely new kind of thing, and not just last year’s model scaled up and given a fancier name? I can’t be sure of it, and that’s sort of the point.
Then the governments showed up, which is how you know a bubble has fully matured. Grown adults who google “google” to open Google are now holding summits about “sovereign compute,” pledging billions, posing next to server racks like generals next to tanks.
And make no mistake about why. The chain is short and entirely about money: the best AI pulls in the most money, and the most money keeps you the world’s number one economy. They know exactly what they’re doing, and they’re riding the bubble on purpose. The whole standoff with China is that same equation read from the other side. China knows it too, and is playing its own cards to come out first. Strip away the speeches about safety and sovereignty and what’s underneath is money, first and last.
The photo ops are funny right up until you remember some of these people command real armies. The same class of model that autocompletes your for loop is being fitted into drones and targeting systems, and “the AI decided” is shaping up to be the most convenient sentence ever invented for dodging responsibility for a decision. From here on, it ain’t funny anymore.
Now. Deep breath.
None of that shitshow changes what AI can actually do for you today.
Where it’s actually good
I’m done yapping, I’ll lead with the good part:
- The boring 80%. Scaffolding, glue code, the CRUD endpoint that looks like the last forty you built, the config, the Dockerfile, the mapping function between two nearly identical objects. The stuff that was never hard, just slow.
- The unfamiliar corner. Dropped into a codebase you touch twice a year, or a framework you’ve never used? The cost of “I don’t know this” fell through the floor. You still need to know what you’re asking for, but the tax on being a stranger somewhere new is a fraction of what it was.
- The fast, ugly prototype. Careful here, this is not “a first draft you keep.” On a fresh codebase with no existing patterns to imitate, AI inherits no taste and it writes crap. But it’s quick, which is exactly what you want when validating an idea. Get your yes or no, then either throw the code away or drag it up to your standards by hand.
- The rubber duck that talks back. Half the value isn’t the code it writes, it’s that explaining the problem to it makes me understand the problem. Sometimes it’s even right about the fix. Either way I leave the conversation smarter, which is more than I can say for most meetings.
- The one-off you’d never have written. That throwaway script to reshape a CSV, parse a log, rename three hundred files. Things that were never worth twenty minutes of your day now cost twenty seconds.
- Debugging the ordinary stuff. Paste the error and it’s often faster than you at spotting what went wrong, and more often than not it’s right. A second pair of eyes never hurts here.
Where it face plants
Ask it to do the actual hard stuff, and it all comes apart.
The change that only makes sense if you’re holding the whole system in your head at once. The performance bug that lives in the gap between two services. The race condition. The thing where being 95% right isn’t good enough.
And here’s the real issue: it almost never tells you it’s out of its depth. A junior engineer would hesitate, or ask a question, or at least look nervous. The model hands you a beautifully formatted, confidently wrong answer in the exact same tone it uses when it’s right. It’s hard to tell which is which. So the mistakes camouflage themselves, and you find them later, deployed in production.
The real skill is knowing, before you read a line of what it gave you, which of these two piles the task belongs in. That judgment is the whole job now, and no model will make that call for you.
Documentation can finally not suck
Documentation was our profession’s oldest broken promise. Everybody agreed it mattered, nobody wanted to write it, and the docs that did exist were either three versions out of date or a single sarcastic README that said “self explanatory” over thirty thousand lines of spaghetti. We all just… accepted it. Reading the source was the documentation. That was the job.
That’s the part I’m happiest to see go. Now the docs can actually exist, because writing the tedious explanation of code you already understand is exactly the work the model is good at. And it works both ways: point it at someone else’s undocumented mess and it hands you the whole picture in minutes, not the full day it used to take.
There’s a catch, of course. Docs it wrote are docs you have to read, because it documents what the code looks like it does with total confidence, which isn’t always what the code does. And the same tool raises the stakes on a discipline we were always terrible at: keeping docs in sync with the code. Point a model at a README that drifted six months ago and it won’t check the source, it’ll take the stale doc as truth and hallucinate from there.
It was always critical thinking
Every hype cycle since the beginning has promised to make thinking optional. Higher level languages, visual programming, no code, and now this.
And every single time, the thing that actually turned out to be scarce and valuable was:
- knowing what to build
- knowing what “correct” looks like
- knowing which of the ten plausible options is the one that won’t hurt you later down the line.
Some would summarise that as “having a functioning brain”.
The model is a phenomenal typist. It’ll happily generate anything you ask, with no opinion about which is right for the context you’re in.
AI didn’t replace the thinking. It industrialised the typing, which means the thinking is now a bigger fraction of what’s left.
If anything, the pressure on judgment went up. The floor for producing code that looks fine collapsed, so the market for people who can only produce code that looks fine collapsed with it. What’s now scarce is the person who reads the output and knows, in their gut, that it’s wrong.
How to make it suck less
Alright, enough philosophy. If you take one practical thing from this post, take this section, because the difference between engineers who love this tool and engineers who hate it is almost entirely in how they use it.
The failure mode has a shape, and once you see it you can’t unsee it. You point the model at a big vague task, it fires back three thousand lines across nine files, and now you’re the tech lead of a team of one very fast, very confident junior who submitted the entire feature as a single pull request at 5pm on a Friday. Do that a few times a day and you’re straight on the path to burnout.
We got into this industry to build ideas into things that behave properly, not to babysit a hundred eager interns at once. So impose the predictability AI won’t give you for free:
- Small diffs or no diffs. Ask for the piece you can fully review in one sitting, not the feature. If you can’t hold the whole change in your head, you can’t approve it.
- The test is the contract. Write the test, or at least the spec, first, then let it fill in the body. The test either passes or it doesn’t.
- You stay the architect. Always. It writes code the way you designed. The second you let it decide it, the structure of your system becomes an average of its training data, and we all know how much slop there is on GitHub, some even dating before LLMs were generally available.
- Review it like it came from a junior. Not every line every time, let’s be honest with each other. The quick, low stakes stuff, you can glance at and move on, exactly as you would have done with someone else’s PR. But the critical path, you read line by line, because you’d never hand a junior something that serious and merge it unseen either, would you?
- Know when to write it yourself. For the harder tasks, wrestling the model into producing the right thing is often slower than writing it yourself, and you end up understanding it less.
I once built an automated pipeline for a company that took a GitHub issue and carried it all the way to deployed in production on its own. The thing that kept it from being a disaster was a filter at the very front: the issues that needed real judgment, got flagged and set aside for a human. The pipeline ran free on the boring tasks, and the 20% that could actually hurt us was never allowed in.
Who’s about to have a very good time
If you’re the kind of engineer who likes fixing ugly broken things, the next few years are going to be extremely good to you. AI is flooding the world with software that works right up until it doesn’t, and somebody has to be the one who walks in and makes it right. That person gets to name their price. Being good at cleaning up messes was always underpaid, now it’s a business model.
The vibe coder, on the other hand. The one who shipped a working looking app over a weekend, has never felt smarter, posted the screenshot on X, and maybe is even revenue positive. They’ll get to spend a good chunk of that revenue paying someone like me to keep the income stream alive the moment it starts falling over. And in a few years, the same way it went with dropshipping and affiliate marketing, we’ll see a lot fewer of them. Thank God. I love a free market, but garbage still belongs in the trash.
But the group I’m actually excited about is the product people. The ones who genuinely carry the whole thing in their head, who used to watch that vision get lossy as it was implemented by engineers. Communication was always the expensive part of this job. It was the distance between what I meant and what got built. And that distance is finally closing. A PM with real context can now rough the thing out themselves, draft a first version of exactly what they’re picturing, and hand it over for an engineer to make real and correct. That collaboration was always possible on paper. It just got dramatically cheaper to pull off, and when it clicks it’s the most fun I’ve had building things in years.
So where does the craftsmanship go?
Some of the joy of this work was in the making itself. That small pride of an elegant solution nobody would ever see. Approving generated code is not the same feeling as making it, you know exactly what I mean. If that stings a little, good. It should. It’s a real thing to lose.
But craftsmanship didn’t die. It moved up a floor.
It is now in the judgment, the taste, the architecture, the review. Knowing what good looks like well enough to reject anything that doesn’t clear the bar. Designing the system so cleanly that a fast, dumb machine can fill it in without wrecking it. Reading a diff and feeling, before you can articulate why, that something’s off. That’s craft, harder to learn and impossible to fake.
The bricklayer became the architect. An older, harder, less tactile role. We grow into it. We don’t have much choice.
And if you’re still learning to lay the bricks yourself, please, don’t skip that part. Yes, you, fresh out of school. Letting the tool do it for you is the most tempting shortcut there is, and you’ll regret taking it. Get your hands dirty first. You have to build the thing wrong a few times before you can feel the difference between good and good enough.
Generalists, specialists, does it still matter?
Honestly? It matters less than it used to.
Specialising on demand got cheap. The moment you need to go deep on something you’ve never touched, the model opens a learning path for you in minutes instead of weeks. It’s a great study partner, and it’s available on the clock.
The generalist has an edge here: they’ve seen enough different things to make sense of the small differences fast, to ask the right question and immediately smell when the answer is off. Breadth and shallowness never meant the same thing, but now more than ever, the former gets you up to speed on the exact thing you need right now quicker.
And the specialist still wins where it counts. Knowing one thing deeply still beats the model at that thing, because it learned the common case, and the deep end is exactly what nobody bothered to write down. What changed is you’re no longer trapped being only that. The same tool that makes generalists dangerous lets a specialist comfortably open a second door, and a third.
Can you afford to be good?
There’s now a frontier model that costs real money and a free one that’s genuinely decent, and the gap between them is real. The expensive one is meaningfully better, and if your employer rations your tokens like it’s the last chocolate in the box, you are going to feel that. There’s a version of the near future where “what model does your company let you use?” becomes a class marker, and where two engineers of equal skill get different outcomes because one of them was handed a sharper tool.
Still, the core of it is simple. The tool multiplies judgment, it doesn’t supply it. A great engineer on a mediocre model still ships careful, correct work. A careless one on the best model on earth just ships disasters faster.
The place this genuinely worries me is hiring. If a technical interviewer sits you down to vibe code something and grades you on the quality of the output, then suddenly you’d need to be paying for the frontier model just to have a fair shot at the job. That would be a genuinely bad thing to bake into an interview, and I don’t think it’s far fetched at all. I hope the people designing these interviews see it coming.
And that same rot grows inside a single company. Watch what happens when the company doesn’t pay for the model and expects everyone to bring their own. Now three engineers of equal skill split on one thing, the plan they’re each willing to fund out of their own pocket:
- one pays for the frontier model, billed by the token.
- one settles for a fixed monthly plan, a decent model that doesn’t wreck the budget. Most people will land here.
- one stays on the free tier to save the money.
Give it two review cycles. The one paying the most simply outperforms the other two, and earns the promotion. So it’s the subscription, not the skill, that decides who moves up and who lands on a performance improvement plan. Do we really want to run teams like that?
The takeaway
The drama around AI is loud and genuinely fun to watch, ideally from the safety of your own atomic shelter. After all, you can’t really do anything about it, can you?
It also has almost nothing to do with the model that helped you fix that bug this morning. That part is all in your control. So use it, it’s good. Just don’t use it for deciding what’s right.
If you’re figuring out how to fold this into a real team without drowning in generated pull requests, that’s a conversation I genuinely enjoy having. Bring your problem, I’ll bring my take.