> Craftsmanship will always be in our hands, it's one thing we can never outsource to a machine.
I'm right there with you, but this last sentence concerned me a bit.
In my most other "industries", craftsmanship is not _dead_, but it's been pushed to the wayside for (significantly) cheaper and more available alternatives. You can still get hand-made leather shoes, but very few want to pay $1000+ for them. You can still get art and paintings that someone poured weeks of work into, but most people buy their wall-art and chachkas at HomeGoods.
The main difference is the disposability assumption, and software is _unfortunately_ becoming more and more "disposable"[0], in the same way other products are. This mindset doesn't align well with software that must continue to operate in order to support some process. A disposable countdown app, sure, throw it away, but anything built around long running business processes should not be treated in that way.
I have concerns that focusing on software craftsmenship frames the issue as "boutique and bougie and unneccessarily expensive" vs "what I need for my usage", instead of "maintable and trustworthy" vs "disposable".
[0] Is that an initiative that benefits large model providers like OpenAI/Anthropic? maybe, but that's not my point here.
Craftsmanship is not dead in other industries in the same way it is being talked about for software.
Sure, that cheap desk that arrived in a flat box and got assembled by me and a screwdriver was mass produced in a factory. But it's design had way more expert craftsmanship put into it than would ever be feasible for a bespoke product. High upfront design cost, then mass produced at a low marginal cost.
That had been the state of art for software from the beginning. When you download Firefox, there is no expert programmer carefully building you an artisinal web browser. There is a CDN server sitting in a data center somewhere copying bytes out of its cache for you.
One of the things AI us threatening to do is replace the CAPEX craftsmanship, which has not happened at scale in other industries.
What AI has had more success at it replacing low end "artisinal" software; which is a category that has thus far been so uneconomical is essentially doesn't exist.
Physical industries are very different than software. Leather shoes are made many times, 1x per customer. Code is created once, using the same product for all customers. This gives a lot more leverage on investing in a quality product.
I also don't agree that software is disposable for the same problem. If it's a temporary problem sure, the code is thrown away and we create something new when another, different problem comes up that can be solves with software.
But if it's an enduring problem? The code sticks around.
I don't think handmade shoes are the right comparison, unless you're talking about software that's meant to be used by just one person.
The more apt comparison might be to the engineers building and maintaining the manufacturing equipment in the shoe factory. It's a degree removed from the consumer, but there's definitely still craftsmanship involved there.
Software engineers are not artists nor shoemakers. They are factory makers.
A good analyst makes a hand-crafted, custom report in a day. A programmer makes a factory that makes thousands of reports per second for a thousand clients.
I am yet to find a factory at HomeGoods.
Now the kind of factories we make might change, but isn't it the fun part?
"software is _unfortunately_ becoming more and more "disposable"[0], in the same way other products are"
Software has been the most disposable object in our lives since you could push a new build over the web. Builds change overnight, new versions every month with small updates. You have it backwards. Software has very little to no regulation compared to physical products and requires little to no effort to change. It has been disposable for decades at this point.
The change is large numbers of developers feel they are becoming disposable.
We will see if that is actually true if any of the AI companies can actually monetize their government cash infusions.
Thought experiment: would a junior developer armed with a modern day gpt-5.5 or opus 4.8 in 2015 would have been considered a 10x developer (assuming nobody knew they were using AI)?
If you want to play games like that, you could also flip it around and ask if the AI would have been eventually fired (assuming no one knew they were talking to a computer).
No. I experienced this firsthand. Brought on a on level dev who was using Ai. Created slop, when asked how it works, he just said “it’s all in the documentation” Lots of good documentation, but that’s bot what I needed. I needed an engineer that understood and knew what he created.
I’m no longer at that org.
> In my most other "industries", craftsmanship is not _dead_, but it's been pushed to the wayside for (significantly) cheaper and more available alternatives.
What if for a lot of software projects out there you don't need craftsmanship but you need something closer to real engineering: "This is what a sane PostgreSQL setup and transaction management for your app looks like, this is how you do validations and the ORM layer and logging and interaction with APIs and request queueing, this is how a good front-end page looks like, here's the off-the-shelf component library you use, here's how your process errors and show toast messages and handle redirects without messing around with browser history, here's all the accessibility and mean things you DON'T do (like hijacking scroll, not having contrast, having too many animations etc.)."
You don't have a rockstar building a bridge, nor do you usually have craftsmen taking risks on innovative materials and new approaches: most of the time, you just build the damn bridge in ways that have worked for decades and have been proven. Software industry doesn't seem to know what is proven or works, cause it's a moving target. Outside of maybe niches like writing code for airplanes, completely different standards there, not sure if most devs would personally want to work in those conditions, though.
Instead on one hand you have orgs and devs that are moving too fast and create a lot of churn without nailing down what works and doesn't, on the other hand you have a lot of people (myself included) that often have to push out slop because tech stacks are a mess and you still have deadlines which don't care about any of that, and largely the state of software development seems like a comparison between Windows 9X, the UI/UX of which was at least partially based on usability studies, and the modern version which... well, you can see for yourself.
I still remember times when my work was mostly cleaning and refactoring old code written just to have higher LOC by devs from India paid in cents per line.
They were creating fast like AI and so mich like AI. But they were merely humans. Cleaning this slow and buggy mess took years killed many companies.
Today we have AI and industrial quantity of code without any engineering skill involved in the process
Yeah, even though I like 'craftsmanship' here, stakeholders don't. I think "durability" is pretty good. 'Engineering standards' perhaps. I think we'll start to see the groundwork laid for software engineering as a proper engineering field, where specific performance characteristics are required for certain stakes.
Code can be like "heavy machinery", maybe needs license to operate. If an app has sensitive data in it, it becomes like a residential structure subject to building codes and inspections. I shudder to think of how this would play out it our oligarchic, anti-competitive environment though.
Hah. What a dream. Instead they’ll hire a team of what is essentially interns and have them deploy mass amounts of minuscule features with 0 guidance because, “hey - it’s cheap as hell and does 75% of what it’s supposed to do.”
A license to operate the code, what a trip.
To be frank, most other business units that are not tech or tech adjacent do not care about the code in the slightest, or the maintenance / security / durability of said code. It’s a tough world to live in. We understand the value of good code, maintainable systems, and proper design across the board. Relaying that to leadership who does not see the value is time wasted.
“What do you mean we need to rewrite it to adhere to engineering spec? It already works. Just deploy it to production”.
I don’t think we’ll ever be treated as engineers. We just had a non-technical person spin up a vibe-app that is now in production, real (measured, methodical, secure, spec driven, efficient) development is actively being devalued at my company and probably across the board…
Rant over. You propose a good solution I just can’t envision a future like this, there’s too much value in “barely good enough”, but perhaps the ramifications of that will eventually bring about your proposed future!
I don't think craftsmanship is dead, but I do think we've built a lemon economy.
The thing that creates the lemon markets is that you can't really distinguish quality until after purchase. This is extra hard with software because the average population is tech illiterate. It's even hard to distinguish when people are tech literate (and not all of HN is). Same thing with cars, most people can't tell the difference, so they buy based on price.
We kinda did this to ourselves. We pushed everything online and killed all the stores. Remember when no one would buy anything online because how risky it was? Then they created "free returns, no questions asked" and people would buy a few things and then send it back? That gave a store like feel with the convenience of home. So everyone moved online, the stores struggled to keep up, the Internet retailers kept running in the red (just like physical stores), the physical stores died, then the online sites needed to get a profit, so free returns stopped or diminished (or drove up the cost of goods. Yay arbitrage! It's like paying for credit card fees when you pay with cash \o/). So now everything is just worse.
We do similar things everywhere. We've started running the whole economy this way. By looking at it through a spreadsheet. Data is great, don't get me wrong, I'm an incredibly mathy person myself, but these are just proxies. To do good data analysis you also need to see beyond the math. To see where the proxy measurement isn't perfectly aligned with the desired measurement. How the measurement[0] can mislead you.
> "what I need for my usage"
I hate how prolific this saying is. You can't know that you have all you need for your use case without first knowing more than you need. It's not something you asymptotically approach, you *have* to surpass it[1]. Without going beyond you, with no doubt, are just setting yourself up to live with unknown unknowns. It's absolute insanity that we say this bullshit with a smug look like we've discovered something profoundly intelligent.
[0] all measurements are proxies. You can't measure anything directly. No, you can't measure a meter. You can measure a comparison to a meter stick. You can measure the time of flight of a laser. You can do all sorts of things like that but everything is always a proxy. If you think this just matters for high precision, well... just look at any house.
[1] an incredibly talented third party could get you exactly to where you need but now you've just doubled the people working
> but anything built around long running business processes should not be treated in that way.
Arguably they are even more willing to cut corners though. Nothing by IBM or SAP should be considered "crafted", yet those companies have a strong place in the world of business today.
I like fixing code made by AIs and others (outsourcing code is similar as someone else said already). Last week we found out some client tried to vibe some departmental tool; the result is some massive crap in nextjs that needs 10GB mem to compile, has 1000s of lint errors, dev logs in git (very noisy ones) and so on. Now we have to fix it: its basically free 10k-50k euros over and over again for this type of work. Very easy if you know what you are doing; impossible if you don't. Keep m coming.
The prototypers, who move fast and break things, who throw together shiny first versions that look great and work some of the time;
The architects, who take the prototypes and take the time to build it correctly;
And the gardeners, who maintain the built system for the next 10-30 years, fixing bugs, making incremental improvements to speed or resource usage, and updating dependencies so that it continues to function on modern machines.
The crazy thing is that there are a ton of developers with different tastes who would love to fill each of the roles, but not many companies that are able to manage all three types without pushing everyone into one bucket.
Ha, I'm a gardener then, on my 15th year of maintenance. So halfway there according to you. Slowly, very slowly, fixing the thousands of bugs the rockstar left behind 15 years ago.
The problem is those shoddy foundations can support a lot of weight before they finally fail. A prototype you write in a day - not a big deal to throw away. However if you have been working for a while that is a lot of effort/money.
Worse, often you need to spend years before you realize how an initial design decision was a mistake - not only are you proposing to throw away millions of dollars worth of work - you also don't know that your proposed better design is really better.
Sounds like valid issues to me. Pristine software isn’t the objective of most businesses. Leaving as a problem for another day, if we’re lucky that day will come, for many businesses, products, and startups it doesn’t and the shoddy prototype usually isn’t to blame.
I feel like SWE’s that make this gripe really need to step back and understand their role and the process for value creation. Because it’s certainly a process, the quality of code/architecture matters little if the low bar of functionality is met. Functionality can be sold to customers or used to test the market. It’s basically the whole MVP thing and the MVP should be a bit jank. If it wasn’t, you spent too much time/effort on it.
All said, there’s definitely some approaches to make it less jank from day one. Unfortunately, jankiness is a subjective metric.
It’s not about pristine software. Customers expect something that works. But changes will then be requested and the expectation is that the software will continue working. It’s hard to do that with janky code.
If you have a good architecture and keep good code hygiene, then velocity is easy. Without that, everything will slow to a crawl.
> If you have a good architecture and keep good code hygiene
That's a big "if" however - customers have a tendency to come up with requirements that aren't covered (or only covered in awkward ways) by the architecture you envisioned initially, while many of the well-architected parts will remain unused.
I don't think I've ever not learned a better way to write something after writing it. Sometimes it's small and insignificant, sometimes it "forces" me to start over. The funniest is when more than half the code deals with something that won't happen. The banana that is not a fruit clause.
You can prototype UX with a tools like balsamiq or taking photos of paper sketches with paper-to-app application. No need for code to share an idea. Especially from business to engineering or vice-versa.
Product Managers coding is like Developers writing marketing pitches.
One of the major concerns with prototyping, at least in my experience and based on the general vibe I've felt from others over the years, is that clients will generally do some variation of "You have a working prototype? So how many days until it is prod ready? No more than a few weeks, right?" and that will be their expectation. AI makes prototyping easier, but makes this specific drawback much worse. Expectations are going to be misaligned, leading to many disappointments, and likely some number of developers taking undue negative outcomes. I'm not even sure if it will normalize to reasonable expectations, given that this tension never seemed resolved even before AI was in the mix.
This is a very interesting thought. We complain about having to fix some MBAs vibecpded slop, but it actually might be faster, easier, and alot less painful than getting them to try to explain their vision to us and implement what they have in mind.
Like they actually iterate on the UX alot when they are vibecoding things up, answer alot of questions that can onky be answered when you see an initial version of experience and realize something is off. Id rather they waste the clankers time with that than mine
I work in IR for small to medium sized business. The past few years have seen my business increase well beyond what I can reasonably handle and my bank account feels like a dragons pile of gold.
I will always always be on the side of security should be integrated and planned for and by no means do I want to see breaches.
That being said giving people of dubious expertise the ability to blast out an app in an hour has been an absolute windfall for me and others.
Agencies that focus on this sort of work are going to make bank. We’ve already gotten some work like this, and it’s just going to keep coming as people think they can vibe code their products. Like you said, easy money.
Lots of people are gambling on AI with big bucks. Some of it is promising but all those bets won’t pay off. I like to think of this mindset as being the human slot machine that people are shoving money into.
Are clients really paying for it? It’s really fascinating actually. Is it because the ”client” built it so they have sentimental value and sold it to themselves before you receive the request?
That is also fixing… The client does not care about technical things so indeed rewrite is usually the best way even if we do not tell we did (people are proud of what they made so they do not want to just get told it was thrown away).
Most devs will say less, but the reality is most of the time you build the wrong thing first, and the price you quote almost never gets what the client wants/expects and includes many overruns.
Every single contractor will say: that never happens when I do it...
This is a better solution for many businesses.
One, they already have a steaming pile of crap that kind of works. Forking that over to someone to "fix" for €10-50k is a steal - even if there's a decent chance they deliver nothing valuable.
You're talking about on the low end a few weeks of a dev's salary. You get next to nothing for that most of the time...
You could easily spend 4-5x that, take 3-4x longer and get something you can't use at all.
As some already said; the real win is into having a business driven prototype; the work to gather those specs is already done and, generally, very costly when done in the traditional way. So from scratch if having to do all of it is more expensive; technical from scratch far less so.
Yes, there's probably a market for vibe-coded software, but if there is, then there's also a market for fixing other companies' vibe-coded mistakes...
Phrased another way, you pay company A to vibe-code some software or extra software features for you, then you subsequently pay company B -- to fix company A's vibe-coded mistakes!
(Hey, look on the bright side! It's more money for taxes, GDP, employment ("jobs jobs jobs!"), and the circular Internet economy! :-) )
Some of this is also going to die out, if the prediction of price increases for LLM tools and tokens holds true. In that case a lot of this software essentially becomes abandonware overnight because the actual maintainer was Claude or Codex.
If you're a reasonably talented developers, I think there will be money to be made picking up projects left behind by coding agents. Maybe you'll use AI tools to do this, maybe you charge to migrate to other platforms and maybe you are paid to simply do bugfixes.
I'm sometimes puzzled by the way people use "circular" to describe an economic system pejoratively. (Not to suggest you are.) Seems like any worthwhile economic system is ultimately cyclical. Pulling resources into the loop is just a bonus....
> the result is some massive crap in nextjs that needs 10GB mem to compile, has 1000s of lint errors, dev logs in git (very noisy ones) and so on.
The anti-LLM propaganda is getting ridiculous at this point. No project "needs 10GB" to compile, unless you're working with astronomically massive repos, and _no_ LLM will _ever_ generate that. Lint errors (depending on cause) are either meaningless or a result of poor prompt engineering. If you want your project linted/formatted a certain way make it clear to the LLM.
Well, this is not the first project that has this. Depending what llm/harness and how it is yielded, this happens, a lot. How often have you had Opus 4.x note; ‘485 failed tests, but those are not related to my changes so I will not dive into them’? You believe someone who does not know about tests or code or linting or compilers will push back on that? I know that’s not happening for a fact.
I have approx 40GB of docker containers spun up at any time in order to run the app I work on, and it only seems to get hungrier by the day. I have absolutely 0 problems imagining a single unoptimized Next app needing multiple gigs just to run, yet alone compile.
You'd have to know what a linter is and tell the LLM to set it up though, right? Or just get lucky and have it suggest setting it up/set one up without asking.
Shameless plug - I've been working on a general repo linting tool alint [0], which helps keep a repo cleanly structured and hygienic - essentially a linter for everything in a repo that a language-specific linter doesn't cover. It also has some considerations for integrating/playing nicely with agentic coding [1]. This started as a replacement to a bunch of scripts I had in repos that did similar things - but more cohesive, readable and much faster.
Do you have any idea, even before modern LLMs, how much code out there was just given more memory instead of optimized? There are even good reasons for it (it can be cheaper than having devs spend time if there's more productive work to be had).
It can be very easy if said code needs to parse through gobs of data.
You've never tried to compile NextJS slop, have you? It absolutely can take that much. All those junkdevs have 64GB in their MBPs for a reason. NodeJS max heap is now dynamic because of this.
The OP said that this was coded by a product person though. The product people coding and using these tools, who are spreading the pro-LLM propaganda, are not doing proper prompt engineering nor lint fixing.
> _no_ LLM will _ever_ generate that
Did you even read the post? Seems you are being overly hostile, defensive and dismissive. Honestly, you sound like an astroturfer to me. I'm curious to check your history to see if you match the vibe.
I've met a handful of people across my life that i'd call truly brilliant. Like, holy heck how in the world is this person this smart? Two things I've noted about really smart people are (usually mutually exclusively) 1) Sometimes they do not realize how smart they are, because it's simple to them, or because they know the subject they assume everyone else, say with a computer science degree, knows and recalls and understands all they do. I've had friends who go off on crypto related maths and I'm like "I passed that class, but know that I do not really know the subject you just talked about" ...
And 2) There's the people who it's painfully forefront of mind that they're smarter than most everyone around them. Some of them are jerks, some of them are exhausted by being surrounded by relatively "stupid" (again, relatively...) people. For the latter group i have some sympathy. Imagine walking through life and everything is clear, obvious, easy to process and having to watch humanity make stupid choices over and over and over again when the answers have been long known...
> Imagine walking through life and everything is clear, obvious, easy to process and having to watch humanity make stupid choices over and over and over again when the answers have been long known...
I don’t claim to be book smart or have a high IQ or whatever but I feel this way about small things that I feel are common sense. It’s maddening to me to watch people fumble around. Or do X when obviously it will result in -Y a bad thing. I really have learned to just not vocalize it, most of the time. It’s especially unhealthy for my close family relationships as I just see so much of it that I could nag them to death.
One of the things I try to teach my kid is: You are going to have to deal with the fact that there are deeply stupid people all around you, without it affecting your mental health. Those stupid people might be in a position of power over you, they might be other kids in school (or coworkers, later), they might be the president of the country, they might be your neighbor, or they might just be obstacles on the road on your way to work every day. You need to learn how to cope and accept this, gracefully deal with them, and how to protect yourself from their stupidity when it might affect you. It's emotional regulation that smart people need to learn or they go crazy.
The older I get, the more I realize that individual variation in humans is truly enormous. Any trait you could pick is much more widely distributed than any individual human can see from their perspective.
Just the other day I was watching a video on youtube, of someone absolutely struggling at a task that had a built-in checklist, verification steps, pictures, and basically (in my opinion) perfect guidance. This is something where, if I was doing it, I would just... do the steps. in order. and it would work, probably... 99.9% of the time, the first time, and relatively quickly, to boot.
I watched them fail to succeed like... 5 times in a row. At no point did they actually complete all the steps and verification in order. And this was a reasonable, intelligent, thoughtful, thorough person. They just could not follow a checklist, visual or written instructions, probably to literally save their life.
Same wrt my wife and I. She’s quite clumsy and to my assertion doesn’t always think things through. So it’s a bad combination for “accidents” to always happen which I think are very preventable and quite obvious to occur using her approach. A lot of it is just mental errors that I don’t make, but it’s not that I’m perfect I probably just make different mistakes (I think less volume too ;)
Yesterday she literally failed miserably at a single task. Her mission was grocery shopping. She drove to grocery store, shopped, and came home and left the groceries in the car. Didn’t realize it until she was making breakfast the next morning and there was no milk.
I see this two ways; 1) I would never make that mistake 2) I know her quite well, partners for over 20 years now, and this kind of thing is just her normal par for the course type of “oops”. The second part is what frustrates me the most, I like to learn from my mistakes and she treats it as a given that she’s just spacey/dimwit by nature and leans into everything being an “accident”. Obviously not healthy if I treat her like a child so I just watch her fumble through life and try to have a sense of humor about it all.
I would say there are two explanations for group 2.
The first is that you aren't as smart as you think you are, because if you actually understood the people around you in any real way, you would instantly find them less frustrating. But instead you are using flawed heuristics, built out of your own insecurities, to interact with the world.
Possibility two is that you are smart, but you have developed a malformed coping mechanism whereby you take all your negative traits (social ineptness, anxiety, impatience) and treat them all as simple the nature outgrowth of your prodigious intelligence. This is a common coping mechanism, and the neat thing is, it has nothing to do with intelligence. You can be dumb as a brick and still feel like you're in a world of morons who are inferior to you.
In fact, I suspect these two explanations are one explanation.
> painfully forefront of mind that they're smarter than most everyone around them
Many devs choose to just do their day job or decide to follow a cargo cult.
Probably not every dev can have the same output, but if you decide to keep
thinking beyond what is the cultural average, then everyone could be smart
in their own way.
It's lonely being an outlier, especially in a trait that's so fundamental to how you see the world. Despite best effort, it's hard to relate to most people, and they especially find it hard to relate to you. The delta of lived experience is quite wide, often insurmountable.
Its never been quicker or cheaper to build something with bad foundational assumptions and principles. Its never been easier to add features whilst not recognizing that it comes with added responsibility. And it will never be too late to hire me for your V2 migration project.
> The flow of data was so hard to follow, it seemed like someone was trying to cover up a murder.
> Just getting the code to run on your laptop took a week.
I always thought I’m the only one having problem understanding the data flow, or setting up a proper dev environment. Impostor syndrome (and sometimes toxic environments that pushed for “velocity”) didn’t help either.
> Just getting the code to run on your laptop took a week.
This one surprised me. Claude Code in the CLI has made standing up an app and debugging whatever random dependencies or docker BS a dream compared to the before times, when you'd have to learn the architecture while simultaneously troubleshooting whatever isn't working on your machine
And in the before times, you learned a lot and walked away with knowledge on the deps needed, connections, .env secrets, and cleaned it all up and documented it so the next dev would have an easier time doing it.
Yes it did. That's how I learned a great many things throughout my career. I'm sure some people didn't pay attention or try to understand what they were doing, and didn't learn. That's on them. But most of us learned a lot that way.
Indeed, there were plenty of people doing just that. I imagine they get the most out of vibe coding. However, when it became a problem, an engineer was still required to fix it.
It might have been you, a couple of months later, or someone else. I have dealt with slop produced by unknowing programmers most of my career. With this vibe coding I think my job is still safe. The amount, though, is increasing exponentially.
I kind of envy people who need to clean up after others. At least you're puzzling.
My current job is genuinely just boring. It's tasks that are so simple, a junior could do it. But no, instead they needed a medior. I'm not saying I'm better than this, nor that no medior will pick it up. I just cannot push myself to care about the code this company makes. It's old, dusty and it serves no one of importance. These customers use it because they once bought the tool and do not care enough to switch, because the tool in question is not interesting.
I was promised work soon that aligned more with my experience, but I do not foresee these customers to come to a stale company like this.
It's not surprising that this company is losing customers, employees, etc. But I have a mortgage to pay. Today I had the conversation about how they might not extend my contract, basically threatening me to take more ownership, do more work, for the same pay. Sadly I have to make it last until I find a new position that is actually interesting. I don't even need a lot of money, I could give a rat's ass about "growing". I just need enough to survive.
This might be a very unrelated comment, in which I apologize. I just do not have another vent to post this to.
You are not alone. I was in this exact same position at MSFT and I put in my resignation. I am an L63 but the work I was doing, was something an L60-L61 could do and I frequently felt I was in one of those Bullshit jobs (courtesy of David Graeber). I was paid handsomely but once the sign on stock ran out, I saw that I was staying in the job just for security. I felt like one of those Hooli engineers who were sunbathing at the Hooli office terrace waiting for their stocks to vest. I am only 9 years into my career and I didn’t see that as the optimal thing for my career rn.
I didn’t have any major financial obligations like you though, so it was a much simpler decision for me.
Hang in there buddy and also thanks for the deeply human comment.
I learned in my 30s that most of the software profession works on boring projects. Uninteresting, low value code, for a barely-working product, used by customers who don't really care, in a low-stakes market that doesn't reward excellence, rigor, or quality. If you can find the rare company where this isn't the case, go for it!
> I am an L63 but the work I was doing, was something an L60-L61 could do
Maybe the problem is imagining that you need sixty three levels of granularity to describe experience or to establish superiority over sixty two categories of "lesser" engineers?
It’s not like the op invented Microsoft’s leveling system. It looks like junior engineer is 59 and 63 is something like senior engineer. I know at google there is a very meaningful difference in the work and responsibilities expected between our equivalent of 63 (L5) and 61(L4).
Believing in that system so much to say something like that might be worse. Noting against the OP, that kind of Stockholm Syndrome can be found in my past as well.
Not sure I understand. Is your contention that the distinction between senior and non-senior engineers is fake and everyone's doing basically the same thing? Or are you just objecting to the (arbitrary) names Microsoft uses for them?
Have no idea why people here are picking up on MSFT’s levelling system? I didn’t invent it.And it actually starts at L59.
The point I made was that as an SSE (L63), there’s a certain amount of scope and autonomy that is expected neither of which I was getting and hence I resigned. I am not trying to bully or denigrate anyone junior.
The levelling system specifies the output and the characteristics of the output expected out of an engineer, that’s it. Whether I believe in it or not is beside the point, I was in the system so I did believe it otherwise progressing through my career would have been impossible.
>Have no idea why people here are picking up on MSFT’s levelling system? I didn’t invent it.And it actually starts at L59.
Because it's standard arrogance by developers not realizing that Microsoft Level system is actually pay bands and because it was developed in 80s, leveling system COVERS all jobs because pay systems didn't support different pay bands back then. So there are lower levels then 59, for things like janitors, secretaries and others who don't make as much as SWE.
At first I thought "medior" was a strange typo for "senior", but on seeing it twice I had to check - apparently it's used in some parts of Europe to mean "mid-level"
> I just cannot push myself to care about the code this company makes.
I can very much relate.
Garbage products, by garbage companies, feeding on the laziness and tastelessness of most, as it's being capitalized by marketers.
And now, to make the matter worse - it's all being 100x by the LLMinazation of the entire field.
Making code unmaintainable. And worse, making us all dumber.
> basically threatening me to take more ownership, do more work, for the same pay
I am a bit curious here. Does that simply mean to should to extra hours and do bullshit duties or is there actually more coding work opportunities? Or do they expect that you should prove more valuable out of nowhere?
I don't want to downplay your experience. In the latter cases, I wonder if you can actually do something.
there is certainly code that sucks; but the article strikes me as someone conflating "code that sucks" with "code that is complex and big and takes a while to get used to".
I have found that a lot of the "massive amounts of bad code" left behind by "rockstar developers" is actually just a long slow drip of added complexity in the face of changing requirements. and I find that people think they're "refactoring the code for readability" when a lot of times, they are actually just "rewriting the code and therefore understanding it in that process".
tl;dr: "Slow down and think about what you're doing when using an LLM." Saved you five minutes.
I was expecting a lot more, or a worked example, or _something_ to that effect. 90% of the text is the author complaining and defining the problem, then a hand-wavy vague solution is presented in the penultimate paragraph. Barely relevant or useful, really.
Almost all opinion pieces are like that. They lack information density, but some readers (like me) like them that way. Otherwise, I'd only read one-line summaries.
I guess some people don't like articles that don't deliver a skill.md to solve a problem.
For me the article is about programmer culture and work ethics, it's hard to discuss with hard facts. Yet sharing this personal experience is valuable.
I mean, go look at the author's linkedin and github. They're a "dev" with 20 years of 1 year of experience. Not a software "engineer"
There's a big difference between the two and LLMs are increasing the chasm. The Software devs are crying out because the LLMs can already do their full job. Software engineers are happy because the LLMs are removing a large chunk of the job that's low value.
Software dev using an LLM is gonna produce "slop"
Software engineer using an LLM is going to have an increase in productivity depending on how they're using the LLM tools.
You make up an false dichotomy. The differentiation between the title and the supposed skill level based on title, is neither true nor helpful to make your point.
Code that is written will have to maintained often by someone else than who wrote the code. So if one write code nobody else understands its an eventual maintenence failure.
You could optimize for different things. Code understandability by the team, speed, technical brilliance.
If you optimize for technical brilliance but nobody else on the team understands the code its still a failure.
The first few sections hit me. I think that I used to be a “rockstar”, until I realized it wasn’t a good thing. Perhaps I could get things done 10x faster than my colleagues. But at some point I realized it wasn’t because I was 10x more productive than a normal person; it was that I worked in a way that made the normal people around me 1/10 as productive.
Since then I’ve slowed down. It’s been an overall positive change for my life. Being a team player unfortunately won’t give you the same kind of upward mobility in this crazy industry, but it’s done amazing things for my mental health.
I've definitely shot my own foot off in the past by implementing things in a rockstar manner. In my case, it typically involves me over-abstracting something that really doesn't need it. Or building something for use-cases that never actually happen. So I have to try to keep YAGNI and KISS in mind whenever my mind wanders into over-abstraction territory.
I was such a fool to lean hard into two production engineers to build the infrastructure around the two very profitable projects I built. I could have made so much more money spaghetti coding it all like a 10x boss and then jumped to Anthropic for one of those sweet 9-figure comp deals. Stupid, stupid, stupid me.
This is where determinism is useful to help avoid these. A tool like Archiet does the determinism side of things and generates working solutions, which can then be given to a human or AI to sort out any gaps. This saves time, tokens and the need to clean up after AI rockstar developers.
Archiet also ships with the right architecture documentation, without the right architecture or specs-driven documentation, AI rockstars need clean up.
Yeah, v1 is sloppy, then I tell the LLM to clean it up. Every 1 prompt of building tends to require 1-5 prompts of clean up. Simple, fast, clean good code.
The chasm between "Software Developer" and "Software Engineer" is getting wider. Articles like this and the comments under it give away who is an Engineer and who is just a coder.
> Every 1 prompt of building tends to require 1-5 prompts of clean up. Simple, fast, clean good code.
I have found this to be very effective as well. However, it's so easy to do, I can't imagine they won't build it in.
The harnesses will improve and the loop of "self-review, judge what needs clean up, do the refactoring, repeat until clean" will get included in the one-shot. They are already doing this somewhat, they'll just get a lot better at it and as the models get faster and cheaper to run, the refactoring churn at the end of each task won't even create a noticeable delay.
I do not think the high-level "taste" knowledge that I've built up -- when to break something off into its own service, what to put in the DB vs cache vs queues vs blob storage, how to isolate important logic in pure functional layers so it can be tested and validated independently -- is any more "unlearnable" to AI than the stuff I previously considered impressive that's now one-shottable like "write a Prolog implementation from scratch".
And yes, right now you still need the architectural and system design knowledge because the LLM will fuck that up. We'll all find out if that continues being needed in the future. From what I understand about LLMs and how they work, I doubt it, but also, yeah, I doubted it would've gotten this far when I think back 2+ years ago.
Also, maybe I should be clear, I pretty much never one-shot things. My sessions with claude or other cli tools always starts with a bit of a conversation until we converge on a good plan, claude builds the code, we discuss some more, then we iterate.
I wish I had current-day AI (and a big credit card) for my previous job, they had a big legacy mess made by a productive but not very good developer, but my job was to rebuild it.
If I had AI tooling at the time I'd probably be more inclined to have it both refactor / optimize the existing application, add automated regression tests etc, and use it to extract all of the features and requirements for it for a potential rebuild.
But honestly I think if that application was properly designed and factored (instead of nesting JS in HTML in strings in JS or concatenating XML from query results only for it to be converted to JSON taking up 50% of response time) its lifetime could've been extended, especially if it was then containerized into a HHVM or similar php optimizer.
Any tips on how you unsloppify things? Are you using things like claude.md/copilot.md (or similar) to guide better, do you have specific types of prompts that you run, or do you adjust your code review practices in some way to more efficiently review lots of slop code?
One of my particular complaints is how code-gen LLMs tend to re-create the same code over and over again. Case in point, a use-case where a team name is generated from a list of team member names. The LLM re-generates this code in-line every time it needs to display the team name, rather than simply writing and reusing a utility style function.
I know I need to fix this. At this point I'm planning to just prompt something like "please list all the places where team names are generated/calculated", plus manually search through the codebase, then perform the abstraction myself. But I'm unsure how to prevent this (both this example, and other cases that could benefit from similar utility functions) continuing to occur in the future.
I accept that for every prompt of building I'm going to have 1-5 prompts of refinement.
Once the LLM tells me "Okay, it's done, everything works" I always as it to do a thorough review, I tell it to split up the work among sub-agents with each one taking on a specific responsibility (look for code smells, look for bad architecture, review the data access model, DUPLICATE CODE, testability and unit testing, etc.)
After a certain number of revisions and reviews you'll come to accept the shortcomings it comes back. Usually there will be specific design decisions you made that the LLM keeps bringing up, once the review only brings that up and maybe some other minor issues it's time to move on.
I don't overly rely on markdown files and directions. I don't rely on tooling around it either. I just don't trust the LLM when it says "all done", tests pass, and deployment works. I make it to multiple reviews and iterations even when it thinks it's done.
Understand what you're writing. If you never build up the mental model of what the code is doing you'll never be able to discern what is slop and what isn't. There are no shortcuts.
Piling more prompts on might get you to the same end result, but without understanding you'll never know when you're there.
Absolutely. I really don't think the future will be humans reading and picking apart an AI-generated codebase, there will be tech debt agents or whatever running overnight.
I think you misunderstand why tech debt lingers around. It's not a capacity or capability problem.
Organisations just don't want to deal with the accountability involved with "touching cold code". Whether it's a human or "AI agent" doesn't change the "It worked in prod, you touched it, you broke it, never touch anything again" dynamic.
That's one dimension of it, but in the context of this thread we are talking about how maintainable a codebase is for other humans. If your codebase is messy you depend on a few key employees and it might be hard to onboard new ones, so there has always been financial incentives to reduce tech debt.
So your proposal to handle tech debt created by "AI" being unable to do good engineering is... throw more AI at it? There's a saying about the definition of insanity which comes to mind.
The ironic rockstar comparison is very good. The classic rockstar only cared about "new" technologies and wrote spaghetti code, the new 100x AI rockstar can do more damage.
It's a pity that the article ends cautiously with recommending to perhaps adapt AI usage practices. In this climate we are not there yet to publish the unfiltered opinion that generative AI is garbage and should be disposed of. Soon we will be.
I think this is fine? Code used to be very expensive to generate, now it is cheap. Building glue logic between well-defined, well-documented APIs has never been easier or faster. There is a time and place for throwaway code that quickly automates a task. It is fast food to fine dining -- not everything needs to be a Michelin star experience.
However, as always, AI usage is a matter of taste. Including your style rules in the prompt matters. Introduce new paradigms/tools/code into the main codebase because they solve a business problem, not because they are technically interesting. Careful development does not break 7 things to introduce one new feature, etc.
I think an important caveat is that LLMs are prone to writing unnecessary code, i.e. there's almost a superfluity to it, that at the same time makes it less straightforward and more prone to unnecessary side effects, which it does catch and handle, but that again expands code further.
Then you add an agent that goes through the code and simplifies it. Before every sprint, you get the agent to simplify whatever it can without losing fidelity.
One argument I heard from a college that the experimental llm written code (not production ofc) should be "write only" - you specify the requirements and constraints and let the machine figure it out - you specifically avoid "fixing it" or "cleaning it up" or reviewing the code because it disrupts the state of this discrete optimizer (over code). Not saying that it is right, or that it should be applied in prod, just noting that this is one potential way to go for non-critical code with clear "win conditions".
I'm reconciling with the fact, that, if I let AI write a bunch of code, I have to depend on that AI to maintain it.
I just spent the last week, hunting down memory issues in the app I'm writing. I had a lot of help from an LLM. It rewrote most of the view controller that implements the map screen. That view controller is now 4,000 lines long (but half of that is comments), but it works extremely well. It took many context resets and rewrites to get here.
I would not have done it that way, but then, I probably also wouldn't have fixed the issue. The issue was really in Apple's MapKit, and I needed to do some gymnastics, to keep it from jetsaming my app. It's not particularly good code; but it works.
I've made the difficult choice to leave the sloppy view controller in the project, with the option of completely ripping it out, in the future, and replacing it with less "intense" code. It's pretty much "firewalled." It won't be that difficult to do it, assuming I have the bandwidth (and Apple finally fixes the memory hog issue, which seems to have been around for a long time).
There's all kinds of options that I could have (and still can) explore, but I feel that this is the best one.
But this article is absolutely correct. I think we will have a "slopocalypse," when it comes time to pay the piper for the thousands of vibe-coded applications that are certain to be authored in the next couple of years.
So far my take has been that there is code that isn't very important, in the sense that if it works it works, it won't be modified or extended much if at all, and it's easy to verify that it works as expected. This type of code I'm happy with letting the AI go wild on.
Then there's important code, like business logic, security related stuff and such. For that I'll happily use AI to brainstorm ideas and avenues, do code reviews where I'm prepared for it to be wrong and help with library suggestions etc, but where I want to write the code myself so I understand what's going on.
We'll see how it changes, been a wild ride so far.
I’ve never seen code that is unimportant. It’s either being used or not. If it’s boilerplate, it can be abstracted away. There are domains that are riskier than others (debug logging vs crypto for auth), but sometimes bugs in a somewhat safe place can lead to some catastrophic issues (you do not have to break a crypto algorithm if the key can be leaked via logging).
>Craftsmanship will always be in our hands, it's one thing we can never outsource to a machine.
Current AI coding is certainly very lacking in the craftsmanship department. But it is not obvious to me that that will always be the case. I don't think there's some fundamental reason AI could never produce code that matches or exceeds the craftsmanship of human experts.
The fact that LLMs fundamentally do not, and cannot, have understanding or reasoning. I don't think you can produce craftsmanship through sheer volume of throwing stuff at the wall and seeing what sticks.
Don't call them rockstars - call them "resume-driven developers."
We had one on our team in the past.
A bunch of microservices built on an in-house RPC framework he wrote, RabbitMQ, half-baked "monads" in an OOP language, esoteric naming, and no comments (the code should be self-documenting!), no docs.
Management adored him.
Once we started to grow, the problems started to appear: bad orchestration, uninformative logs full of PII, poor error handling, edge cases that were nearly impossible to fix within the existing abstractions, dependency hell, etc.
At that point, he moved on.
It took years and many hundreds of pull requests to clean it up.
This is why I always work at a new company at least 6-12 months before making any major changes. I use that time to get into the flow of how things are being done (even if I think they are not efficient). I may make some suggestions but that's it.
Of course, I'll probably never get hired again anywhere so it doesn't matter anymore.
I heard this kind of rockstar stories a lot from my friends but I never encountered one in real life. I worked in small and big companies and no one with allowed to use any obscure language or tooling. I count myself lucky.
Like many other critiques along this line, I think the answer is: Yes, for now. For example, in my own code base, I have an agent dedicated to maintaining a sane data model. This agent reviews the plan in advance and again during code review. And then I review the code myself. This seems to be sufficient for my work, at least. YMMV. It was a good post though. I enjoyed the take and the writing.
I’m sure the general premise around AI-generated code is accurate. That being said, I’ve definitely had interesting moments where e.g. Claude produced code that matched the pre-existing codebase quite nicely, and slowly started building up its memory of how new pieces fit into the codebase in an idiomatic way. Then again, it started to throw in Tailwind-based CSS classes all of a sudden, because it assumed that Tailwind had been set up (it wasn’t).
One thing I’ve found helps is leaning a bit more towards a modular almost microservice like model with clearly defined interfaces. Gives you a bit better control than a huge unified ball of AI spaghetti code
I don’t think the analogy between rock star developers and LLMs bears out here. Like any other tool, AI abides by the basic reality of garbage in/garbage out. If you don’t make sure the LLM has sufficient context then you get what you get. Same point with vague prompts.
AI tools are producing code on behalf of a developer. If that developer is fine putting their name on code that they don’t understand, applied to a code base they also don’t fully understand then you have a very human problem. The technology just magnifies this.
Is the "Cleaning up after hundreds of AI rockstars" part a description of an actual experience? I don't feel that it is. I would expect much more swearing if it were the case.
This is a confusion that you could not have predicted, but primed by your comment, I expected "terminal star" to refer to a suggested predecessor of the AI rockstar. No, it refers to the animated Claude Code star :P
The post seems to not address the fact that different product phases exist which in turn affect the software. Similarly, teams are different and get assembled for different purposes. There is also a difference if software was created in the past 24 months vs past 10 years. It is very easy to attack decisions made which look messy now, because many reasons. Everything looks obvious in hindsight. And then making it ad-hominem like does not sound smart, it is a clickbait, the issues are usually more complex.
Sometimes I wonder if any of this will even matter in a few years. How many of us compile code and then have to clean up the assembly, or even worry about what a compiler generates as long as it's correct?
I realized recently that this all has an unsavory element of ego to it. It doesn't help that LLMs have basically been trained to talk like they're performing in a movie, getting creative with techno-babble that sounds both plausible and exciting. I recently had to review some slop where the LLM was using terms like "event storm" to describe how some callbacks work, or "gating-solve" to describe a simple change to an if statement. Combine that with their sycophantic tendencies, and it really can make you feel like you're a star hacker in a Hollywood movie.
It reminds me a little of when Hegseth wrote "we're clean on opsec" in a message thread with confidential military information that he accidentally sent to a journalist. It seems like role playing/fantasy fulfilment for certain personalities. I struggle not to hold some contempt for people like this, who are making life difficult for everyone for their own petty reasons. I can sympathize when it's simple ignorance, but the ego chasing really is inexcusable and needs to be called out more.
Funny, the element of ego I'm seeing are the devs that can't accept that LLMs write perfectly good code at a faster pace. It's always "slop" this or "vibe coded" that. Meanwhile I've personally shipped multiple apps and professionally we've done HUGE things in these past 6 months using LLM tools.
Not sure what I'm going to link to in my professional life, it's all private repos. We have a large microservice architecture in AWS. We've made major changes and the LLMs have helped every step of the way. Migrated our whole auth system from being regional, resulting in customers being limited to specific regions or managing their multiple accounts across regions, to a global authentication with data residency built into accounts so that they login to what looks like a global app now. No more uk.example.com, eu.example.com, ca.example.com and us.example.com. It's now just example.com, but data residency (and currently data processing too, but that's another thing we're working on) stays the same. This isn't some small app, this is the main product at a company with nearly a Billion in ARR.
For personal projects, only one thing could I actually show - vaicayo.com
This app was originally started pre-llm. I just wanted a centralized place for my wife and I to organize our vacations. I built out the basic crud for that a long time ago and we used it, but then llms got popular. I first integrated it into the app, now I could get it to generate vacation plans completely with the llm. It did okay.
Somewhere between 3-6 months after building out llm features claude code released or I became aware of it enough to start using it.
I rebuilt the whole thing. So what was once a spring boot app running in AWS ECS with alb + cloudfront (and yeah, some sqs+lambda python processes, s3 buckets for storage, aurora rds for db) is now a super lean apigw + lambda + dynamodb stack with a svelte frontend. I went from paying $20ish a month to $0. I also built a flutter app for android and ios that utilizes the same backend as the frontend webapp with feature parity. It's not really a production app, but it could handle it fine, it's completely cloud native and hands off to operate. And let me be clear about the rebuild, it's not a 1 for 1, I think all that I kept was the domain model.
For features, it's mostly just a crud app. You plan your vacation in it. Outside of that there's the ability to take pictures with the phone app that auto-sync (there's a bit of complexity here, the phone app only syncs pics when it's on wifi unless you change settings to allow syncing on cell network, images are cached locally with a ttl, uploads will run in the background and queue up, uploaded images automatically resize/compress and generate thumbnails from an s3 event lambda). The other more complex item is email ingestion, when I get a reservation email I forward it to the app and it automatically processes it (the only place I use an LLM in the app right now). If it can't discern what the email is or which vacation it goes to it goes in a travel inbox so the user can route it to the right vacation and object type. Oh I guess the paywall is a little complex. I don't advertise this thing but I have left user registration open if anybody ever wanted to use it. I did lock the email parsing behind a paywall and I limit photo uploads for free accounts.
So frontend, backend apis, flutter app for android and ios all built 100% by llm.
For code quality, the frontend is okay, the backend is pretty clean but could use some things split out into domains, and the flutter app has some work to do (recently found a couple code smells). But there's no issues adding features, shipping, etc. I literally finished adding some of the photo syncing features in the flutter app last night.
Other than that, I have created 5+ other personal projects that I wouldn't have without an LLM. I've made 2 godot games, a private scribbl.io clone with a few extra features that myself and my coworrkers play as a "happy hour" on fridays, tons of ci/cd build stuff and terraform (using my own personal modules, so I guess that's not 100% llm coded if you consider the modules), and then a couple other simple apps.
The job when picking up a codebase made by human or machine always involves reverse-engineering the design intent from code. That's especially hard for LLM-generated code because the path to runtime was so rushed.
> It's more expensive to fix code at runtime than at compile time and at compile time than at design time. Unfortunately, AI rushes people to runtime as fast as possible.
One of the things that annoys me is that we could know what the original intent was, and indeed the preferred form for modification: the prompt! Yet for some reason there's no standard/tradition/expectation that people commit all their prompting.
Perhaps I should start trolling people that your software is not truly Open Source if it's not Open Prompt.
In my opinion the problem rather is that most managers do not value elegance of the code, and most programmers are either too obedient or too clueless to dissent to management. Also, most team members don't want to understand highly elegant code and its inner beaty.
If management and teams would instead value highly elegant code structures over lots of "spewed out" code lines "that (superficially) implement a feature", I would bet that the problem discussed in the article would be much less of an issue.
I’ve cleaned up after outsourced code and it has a different flavor to AI rockstar code. In the former, you can see that the developer only care about the current ticket. After every merge, it’s a flurry of bug fixes, because they always break something unrelated. And that’s due to bad design, you will see a lot of copy pasted code and unused code.
As for the AI code, the most defining elements are unneeded complexity and low understanding of the abstraction involved. When you need a 10 lines functions, the AI will happily write an entire module because that’s how a fully implemented domain is like. But it’s not part of the requirements. As for the low understanding, you will see strange code, which are not fully antipattern, but are definitely not needed as it solves issue that the platform/library/framework doesn’t have or already have a solution for.
this resonates with me, but fortunately one difference between LLMs and rockstar developers, is that LLMs will at least _try_ to explain what they are doing, and why something has to be certain why. I've gotten quite a lot of mileage from being a five-year-old with Claude and just asking "why" until I'm satisfied
I've said it before, I'll say it again, I'm convinced LLMs will be the thing to convince software engineers to get it together and create a licensing board.
There's a difference between introducing new things because they are a well thought out appropriate choice and completely ignoring the standards of the company because you want to do resume driven development. I believe the author is talking about the latter.
The point is that developers like this purposefully introduce new languages and frameworks that only they (and maybe not even they) fully understand, so they make themselves harder to replace and ensure that they appear ahead of the curve. (Then they get bored and leave anyway.) It's totally valid to introduce new technologies when the problem calls for them, but doing it in a way that's purely detrimental to the rest of the team is very selfish.
Rockstars, AI or not, were 'successful' because they defined how success looks like. They created that perception and called it success. Not many people would bother going beyond the perceptions. They don't know how success or good code looks like. Rockstars gave them the playbook.
In reality, sometimes I wonder if there is really anything beyond perceptions.
Story time! I Worked with not just a "rockstar" but what I suspect was a "superstar" for about three years at my last gig. It was a small company with about 3-4 developers at any given time and we worked on an embedded Linux product in a moderately safety-critical industry that had a messy ~25 y/o codebase and a custom, roll-your-own Linux distro on custom hardware. Our "superstar" had been with the company for ~10 years and due to really high turnover I was the most senior of the rest of the staff with 3 years. The manager of the software team claimed to have 10+ years of software development experience on his resume and LinkedIn, but would ask CS 101 questions in our software planning meetings.
The basic workflow adopted by our manager was thus:
1. Discover a bug or get a feature request
2. Pass the task to the development team verbally
3. Developers prioritize tasks based on which ones are more likely to be forgotten by management
4. Approx 20% of tasks get completed
5. Repeat step 1
You might think, with our superstar developer, a workflow like this would be possible. Honestly, I saw him do things (pre-AI) that were astonishing. He would work a weekend and add a feature I thought would take 2 weeks. He created a re-write of our main product and demoed a completely new product using the same hardware by himself in about 6 months. He would take feature requests not assigned to him and just do them before the assigned developer was even finished planning the feature. The sales team would come in with a pitch for an insane new feature idea (like add a Farsi version of the UI) on Friday, the rest of the team would attempt to push back on it, then he would check-in a semi-working version of that feature on Monday. For these reasons our manager loved him and would always ask the rest of the development team why we couldn't keep up. It was demoralizing and frustrating. At the same time, as a company, we were mostly unable to get very simple changes out the door. Most of the insane features we added died on the vine before getting to the customer (but the code would remain polluting the codebase). Any bug that was fixed would reveal 2 more serious show-stopping bugs. New software releases were regularly regressed: they would break one of our customer's use cases and because we never created basic functionality like OTA updates, we would fly a tech out with a flash drive to revert all the software. We worked on 3-4 new products an not a single one ever saw the light of day. Our company github was littered with dead, abandoned, duplicated repos.
Basically our superstar developer absolutely allowed our non-technical management to commit software development seppuku. His successes were highly visible, but his failures were not:
1. Clobbering other developer's commits because he didn't know how to use git to rebase or merge changes
2. Copy pasting (not forking) entire codebases to work on a new feature that then got so bloated they were impossible to merge
3. Absolutely no documentation of any sort, not even comments.
4. No automated testing of any sort on any of his code even though there was an effort by the rest of the team to do better testing.
5. Refusal to use the common Docker development platform everyone else had standardized on, many times his code only worked on his machine.
6. He wouldn't fix bugs, he would just re-write the core logic of the feature that had the bug and then he wouldn't bother to remove the old logic.
7. Regular, daily code dumps of 1000-2000 LOC that contained new features that were not discussed by the team, sometimes from casual conversations with a sales person, sometimes completely made up by him out of boredom I guess.
8. Our Linux BSP was stuck in Amber because the only copy of it was on his local machine (allegedly). When asked many many times by the rest of the team to get it in our company repo he would check in something that did not compile and was not even remotely close to what was being used on our boards.
9. Instead of adding dependencies where needed he would take a 3rd party library, chop it up and copy-paste it into our code directly (see point 8).
10. Last but not least just general slop code with 15-20 levels of indentation, no modularity, dirty hacks everywhere.
I think about him a lot when I think about companies going all in on productivity maxxed vibe coded AI. I think that under better management that restricted his impulses and gave him more structure, he could have been a great asset to the company. Unfortunately when let run wild over the company codebase he was an absolute menace and ultimately led to less actual useful work getting done and an erosion of customer trust. I think this might be the reason we are getting two diametrically opposed experiences with AI: it is either going to destroy your codebase or deliver features at an astounding pace, and I think the difference is the actual technical knowledge of who is managing these projects. My guess is that there are a lot of places with middling or non-technical management pushing AI coding that are going to be in struggle city in a year or so and not understand how they got there. "But AI was making us so productive!".
That's because the businesses got into the habit of new C level means new project, obviously the old code is bad.
I even had a PE buy the company I worked at, put in a new CEO, and his goal was to rewrite the entire code base in a year. I asked him what problems this would solve and never got a straight answer besides "its yucky" and "people told me they dont like it."
I have had multiple upper management teams decide that "dealing with this product is too hard, let's start from scratch" as if the new thing wouldn't have the same problems of the old thing, but with less effort put into it.
People love to work on new, all the possibilities and none of the bugs!(yet)
Yep, I worked at a small company that got bought by a bigger one. We had a solid if aging product to support which was one of the big players for the niche. Once there was a leadership change, 2/3 of the devs got put on building a replacement software. Then in a couple of years our subgroup got spun off and sold to PE and the v2 project was shelved for another brand new design to align with the new ownership. I left just before the spin-off, but witnessed how the original software slowly rotted away and all of the marketshare dominance we had for that area slipped away.
Devs love new tech and the product people love something new to put their stamp on, but chasing that high can be ruinous.
I have seen over the past decades this concept of just reusable throw it away code becomes the norm and that’s why also I’m always surprised to look at people complaining about AI development and it’s like yeah it’s just the same as all other development at this point everything‘s just frameworks and throwaway code
I’m not even mad at it but it’s just one of those things where people are like “I’ve never dealt with anything like this”
But it’s the majority of operational software engineering since more or less forever
I think its also the pyramid of age - as you work in this field a lot of people burn out, the field was significantly smaller in the past and has shown huge growth, and the young say "yes sir!" and work nights and weekends on the fucking stupid idea while the older folks push back.
So in general most of the people have worked on a bunch of greenfield development, thought of the project 2 years old as aged out entirely, and never thought you might "maintain" something at all.
In my experience, this is because a modern engineering organization is laser focused on delivering value. Value rarely aligns with refactoring an existing, working implementation. If need the data, you build an integration on the output data. If something isn’t working well enough, you fix that one thing, you don’t refactor half the application.
Getting product to prioritize refactoring a working product is like pulling teeth. Even if maintenance is a moderate drain on resources, work beyond maintenance on working solutions isn’t seen as a net win.
It's different because LLMs can generate code that immediately needs to be refactored at speeds that were unfeasible before. There was a practical limit on the amount of technical debt that could be created in a day before, now that limit is 10x or 100x higher. It can be generated far faster than it can be fixed.
Then code factoring was never the key problem was it?
It was organizational discipline
Again this is the same problem previously…organizational lack of discipline means you get some diva to build some un maintainable thing and then you have to go back and refactor it later
The problem is the same the speed is different I acknowledge but both our organizational problems and have nothing to do with writing code or technical
If a neighbor leaves their dog's poop in my yard I have a problem.
If someone builds an industrial scale dog poop delivery mechanism that delivers tons of dog poop to my yard every day I have a different problem even though the underlying basics are the same.
The problem in isolation isn't new as such, but I think there's a combination of new factors to differentiate it:
1) the speed at which AI-generated codebases grow is far in excess of what human developers can achieve. What took years to accumulate in the past can be produced in a few days/weeks.
2) past large codebases that end up in a similar state would often see a mixture of developer talent. So while you might have a few developers who produce dross, there will also be a few who can pull it back together. You start to see threads of sanity appear, and from that the potential to refactor further, rather than the uniform spaghetti monster that's near unassailable from every direction that we're now getting from the pure-AI projects.
3) external perception differs. AI has been pitched, sadly by sales, influencers and shills rather than experts in the field, to business leaders as the solution to all development problems. When you present this issue to stakeholders you're then immediately put on the defensive, e.g. it's initially viewed as negativity for the sake of negativity. With past technical debt discussions, outside of a few key parties (too often the person responsible for overseeing said debt developing), I've found that it's relatively straight forward to explain technical debt, the need to refactor and maintain systems as a going concern. For the technically disinclined it's easy to draw parallels with building maintenance: you don't expect to build an office and then never spend another cent, it takes continued investment and maintenance to keep it safe, clean, functional and compliant. The difficulty again with the AI projects here I think comes back to the accelerated timeline, as you're inevitably going to be saying months after it's created that it probably needs to be burnt to the ground in lieu of the far greater task of refactoring it. As opposed to a legacy project that has been going for years or decades, where it's a far more palatable concept to take drastic action.
If you're just starting to learn programming, people will tell you that maintainability is important, and they'll mention John Ousterhout's concept of the "tactical tornado" as an anti-pattern.
The problem is that this approach implements features quickly but in a way that conflicts with the team's mental model, ultimately ruining the entire codebase.
A lot of blog posts initially framed this as a problem. I agreed to some extent.
But as I've gained more programming experience, I've come to realize that all programs degrade over time until they are reborn. Eventually, it seems that destructive innovation is necessary for longevity. And sometimes, new patterns emerge from that kind of disruptive feature development.
So you could say that AI rockstar developers and AI-driven development are close to being a "tactical tornado" because their codebases are bad, with poor maintainability and reliability.
Maintainable development, in my experience as a traveling contract developer, usually refers to code that is well-modularized and well-crafted, making it easy for someone like me to understand the codebase when I come on board. But when I saw the leaked Claude code, frankly, the code quality was disappointing—yet by my standards, it worked very well.
So I've changed my mind lately. I think we actually need a new classification of developer types: those who love creating new things but are bad at maintenance, versus those who are conservative, good at maintenance, and build beautiful code.
What makes me think not too badly of recent AI-Rockstar(or AI vibe)developers is that as any industry becomes more advanced, it becomes harder for stars to emerge. Work gets divided and specialized, and no single individual can master everything. For example, I'm confident in writing 60,000–90,000 lines of code by combining frameworks based on IoC (Inversion of Control). But I'm weak at large-scale programming like distributed systems or low-level programming. That's the difference in expertise. I'm strong at the macro level but weak at the micro level. You become cognitively optimized for your own domain.
vibe coding developers(or AI star developer)since AI is still far from being highly advanced—produce messy code, but they definitely bring a new kind of shock. And when you look at their internal structure, many developers mock them. This reminds me of Undertale. Undertale's code is full of if statements and an enormous number of branches—honestly, it seemed like the developer didn't even know the basics of coding. Yet that game became a historic success. The same goes for programming. Some people make the code components beautiful and efficient, while others focus on delivering what the end consumer wants.
So these days, I even think that the more AI developers create bad software using AI, the more new jobs will emerge to maintain that software. Everything always has two sides, it seems.
And in a way, maintainability means knowing how that feature fits into the overall shape and UX of the product. With new products, that prediction is often impossible
I believe GNU Emacs was created in 1984 or 1985, and it's still going strong. I guess it's not easy to work on it due to the long history, but I understand it's been refactored as the developers went along.
Please write a manual on how to cleanup after AI rockstar managers who think they can code.
Much needed right now as I slept only two hours since yesterday after solving a SEV-0 and having to wake up after a 2 hour nap, so I could be now cleaning up the fallout before business hours.
I am not a AI-denier, I am actually thankful I have AI right now to multiply my force, but frankly, people STILL need to review that fucking code, and the people who review the fucking code STILL need to be good enough to be able to write it themselves if they needed.
Whoever says otherwise is either an AI investor, a linkedin influencer or a complete imbecile.
--- EDIT
Please add a section on how to communicate and write a post mortem where the guilty is completely exhonerated without the blame falling on me as I try to save said manager's face.
> Please write a manual on how to cleanup after AI rockstar managers who think they can code.
Why are you allowing AI rockstar managers to (I assume) push without code review? Why are you cleaning up the fallout? It's not AI issue, it's people issue
It's the mandate from top-down. Of course it's a people issue, the problem is that the people creating this issue are exactly the ones paying us.
My manager got the mandate she needs to start coding, she doesn't want that, no one in our team wants that, she's a great manager exactly where she is right now. Nonetheless, we are helping her to code to show something for the higher-ups so she can keep her job, we really don't want to lose one of our best managers because some C-level is anxious about AI...
- show increase in errors and outages caused by this approach
- integrate manager changes into your CI pipeline (coding / reviewing / testing / documentation)
- discuss how your manager can do the changes they need to do without sidetracking all other work
Make it indeed about the money: coding by PM + fixing what was coded + dealing with fallout is greater expense than coding by PM + automated guidelines + reviewing what was coded.
That is - if the environment you're working in is reasonable and it's not a power play by your PM
I don't know why you assumed it was a PM thing, the mandate is for EMs to be more "hands-on".
On your points:
Manager changes are always going to go through the usual pipeline, we are 10k+ people so there's not even a way to go all gung-ho pushing stuff. They need to be reviewed, approved, etc.
But we don't want our manager to code, nor does our manager, so we are just helping to cross the bare minimum expected from higher ups. For my team it's not an issue with our manager's code (those will be at max small fixes, well-defined, the most trivial stuff), the issue is they are mandating managers to do it.
I don't know what size of company you work at, where I am at there is simply no incentive for me to do all the extra work to show execs/higher management the issues cropping up.
I don't even have access to them, I have to pass through other channels, those might compile reports from many people to try to present a case, if they get to present a case then there's a whole other discussion to happen at director/VP/C-level about what they want to do, and since it goes against their big mandate it most likely will just be thrown out.
In this structure I have no motivation at all to go out of my way to perform data gathering/analysis, wrapping it all in a nice concise document explaining what the data means, potential remediation, etc. just to become a footnote in someone else's document that ultimately will not change anything from the VP/C-level mandate.
I assumed that as it was hitting too close home (both PMs and EMs were expected to use AI, with PM trying to code in solutions that they didn't have expertise nor domain knowledge to deal with; EM was prototyping solutions that had access to prod DB that were shut down as soon as we found out). I can only symphatize nonetheless and thank you for giving your PoV.
Because most people, in most parts of the world, are not allowed to question whatever their superiors do? And, yes, unfortunately are also expected to clean up after said superiors' messes. Of course it's a people issue. AIs just make people issues worse in new and entertaining ways.
The code is AI reviewed, and I was ordered to change repo setting so a single AI review is enough. I've tried suggesting a lot of things, but it is not on my paygrade to allow or disallow something, only recommend.
100%. You don't "clean up after them." You make them clean up their own mess. You refuse to let a mess into the system in the first place.
Same as it ever was.
The only difference now is that if you let it happen, it'll happen 100x as fast.
When I was mentoring junior devs, I would start by fully reviewing their code. If they had a ton of mistakes more than a few times, I would only review until the first mistake, and then reject it. Repeat, repeat, repeat, until they got the picture that I wasn't going to let mistakes through, and handing me a ton of mistakes was going to waste more of their time than mine.
I let the pain be their pain, instead of mine.
But good developers, I'd help them by doing a more thorough review and not wasting their time. Good developers were the ones that made an honest effort to follow the requirements to the letter and test their own work.
We further emphasized this by having a very simple coding test during the interview, and the only thing we cared about was whether they followed the requirements to the letter. There wasn't a lot left to the imagination, and the requirements were very clear. Anyone who missed them wasn't someone who would do well with us.
That very same test will help filter out a lot of AI-braindead candidates that don't check the AI's work as well.
Actually, I wish I still had the exact test so I could throw it against an AI and see what happens. I'm a little afraid that it would pass it too easily now. I'm not sure how I'd fix it to prevent them from just using AI.
Hmm, ~30 years ago the compilers that I was using were generating generally fine assembly/machine code. Some of the other tooling was more troublesome: cross platform high performance numerically stable code and C++ static template deduplication paid for a lot of beers around then, and I needed them.
Compilers are deterministic and they actually possess domain knowledge of what they are trying to do. AI models are non-deterministic, have no real domain knowledge due to lack of an underlying world model, and their way of "writing" software is to spew out something that looks like something that they have been trained on, then iterate on it long enough until it has reached the level of being barely runnable.
AI is absolutely deterministic, just as much as a a car is, with a human driver (who is also soon going to be replaced with AI anyway) .. I ship more, fix more bugs, audit my code for security more and thoroughly enjoy not just the process of building, but also the asymmetric power i wield by out executing my well funded competitors with 100 developers and 10 testers dnd 5 devops and 10 full time sales staff.
> Half the code was written in a language you didn't understand. The other half was written using libraries you never heard of.
> As you waded through the slop, you browsed job postings and fantasized about leaving
Just because you didn't understand something or haven't heard about a library, doesn't mean its slop. How do you make sure your definition of "clean code" is not a slop to others?
I'll avoid trying to guess what the author meant, but I found it rather relatable. Some of these "rockstars" pick weird languages, niche database, esoteric frameworks and whatnot, not because they're needed, but because that's the rockstar thing to do at that moment. And then they leave and you're stuck managing a Cassandra database and a Rust application when everything else around you is MariaDB and Java, and you have to maintain an application in an abandoned JavaScript framework, even though dynamic frontend wasn't a requirement.
This isn't a problem with "rockstar" AI devs. This is a problem of management. Who would let someone come in and rebuild the core infra of their business without any planning or review?
This article feels is trying to justify their own inefficiencies (lack of library or language knowledge) instead of taking the time to learn from the rockstar and their technology choices.
As I was leaving my last job, I advocated everyone migrate from plain old es6 to typescript, b/c several times broken builds made it to production.
Certainly my coworkers may of felt upset that typescript is too verbose and pointless if everyone reaches for the "any" operator. But that doesn't mean the decision to move to Typescript was bad, it just means the company is "old school" and not willing to take the time to adopt modern workflows...
> Sometimes there's so much technical debt that it can never be paid off.
There is no such thing as technical debt in the age of AI. It's just a series of migrations that take minutes to come up with.
I migrated from two disparate databases using AI and it took minutes for it to write the migration code. I had it double-write the data, and then I told the AI to write code to compare between the two databases, and I then tested over the course of a week.. I fixed some small bugs, or more precisely I told the AI to fix the bugs and it did.
Then once I was satisfied, I switched it so that the new database was primary and the previous database was secondary. Then I tested to make sure the data was still in sync. Then I switched off the previous database, then I removed all traces of the previous code.
It was simple and relatively quick. The thought that there exists technical debt in this age is absurd. One person can do things an entire team used to take in a fraction of the time.
Never mind the huge, untouched, unspoken-of debt to all the people whose work--literary, artistic, software--under various licenses, or without, it (rather THEY, the owners and co-conspirators) are taking and re-using, without attribution, without credit, nor payment of any form. Not even a thanks (because as soon as that is acknowledged it will enter the consciousness and then the question of injustice will dwell--and we can't afford to have people thinking about that).
> Craftsmanship will always be in our hands, it's one thing we can never outsource to a machine.
I'm right there with you, but this last sentence concerned me a bit.
In my most other "industries", craftsmanship is not _dead_, but it's been pushed to the wayside for (significantly) cheaper and more available alternatives. You can still get hand-made leather shoes, but very few want to pay $1000+ for them. You can still get art and paintings that someone poured weeks of work into, but most people buy their wall-art and chachkas at HomeGoods.
The main difference is the disposability assumption, and software is _unfortunately_ becoming more and more "disposable"[0], in the same way other products are. This mindset doesn't align well with software that must continue to operate in order to support some process. A disposable countdown app, sure, throw it away, but anything built around long running business processes should not be treated in that way.
I have concerns that focusing on software craftsmenship frames the issue as "boutique and bougie and unneccessarily expensive" vs "what I need for my usage", instead of "maintable and trustworthy" vs "disposable".
[0] Is that an initiative that benefits large model providers like OpenAI/Anthropic? maybe, but that's not my point here.
Craftsmanship is not dead in other industries in the same way it is being talked about for software.
Sure, that cheap desk that arrived in a flat box and got assembled by me and a screwdriver was mass produced in a factory. But it's design had way more expert craftsmanship put into it than would ever be feasible for a bespoke product. High upfront design cost, then mass produced at a low marginal cost.
That had been the state of art for software from the beginning. When you download Firefox, there is no expert programmer carefully building you an artisinal web browser. There is a CDN server sitting in a data center somewhere copying bytes out of its cache for you.
One of the things AI us threatening to do is replace the CAPEX craftsmanship, which has not happened at scale in other industries.
What AI has had more success at it replacing low end "artisinal" software; which is a category that has thus far been so uneconomical is essentially doesn't exist.
Physical industries are very different than software. Leather shoes are made many times, 1x per customer. Code is created once, using the same product for all customers. This gives a lot more leverage on investing in a quality product.
I also don't agree that software is disposable for the same problem. If it's a temporary problem sure, the code is thrown away and we create something new when another, different problem comes up that can be solves with software.
But if it's an enduring problem? The code sticks around.
Slightly agree. :)
I don't think handmade shoes are the right comparison, unless you're talking about software that's meant to be used by just one person.
The more apt comparison might be to the engineers building and maintaining the manufacturing equipment in the shoe factory. It's a degree removed from the consumer, but there's definitely still craftsmanship involved there.
Going to be awfully hard to market rote machine maintenance as craftsmanship, but there are some suckers out there
Software engineers are not artists nor shoemakers. They are factory makers.
A good analyst makes a hand-crafted, custom report in a day. A programmer makes a factory that makes thousands of reports per second for a thousand clients.
I am yet to find a factory at HomeGoods.
Now the kind of factories we make might change, but isn't it the fun part?
> Now the kind of factories we make might change, but isn't it the fun part?
No, I don't think it's the fun part. Judging by the number of people glooming over LLMs, not many people seem excited about it.
Great programmers learn all documents are high latency state-machines.
A "Report" is just a document feature projection.
People may initially think this is in err, then think again... =3
I remember when the Mac made everyone a publisher.
"software is _unfortunately_ becoming more and more "disposable"[0], in the same way other products are"
Software has been the most disposable object in our lives since you could push a new build over the web. Builds change overnight, new versions every month with small updates. You have it backwards. Software has very little to no regulation compared to physical products and requires little to no effort to change. It has been disposable for decades at this point.
The change is large numbers of developers feel they are becoming disposable.
We will see if that is actually true if any of the AI companies can actually monetize their government cash infusions.
Thought experiment: would a junior developer armed with a modern day gpt-5.5 or opus 4.8 in 2015 would have been considered a 10x developer (assuming nobody knew they were using AI)?
If you want to play games like that, you could also flip it around and ask if the AI would have been eventually fired (assuming no one knew they were talking to a computer).
Not sure what that proves.
No. I experienced this firsthand. Brought on a on level dev who was using Ai. Created slop, when asked how it works, he just said “it’s all in the documentation” Lots of good documentation, but that’s bot what I needed. I needed an engineer that understood and knew what he created. I’m no longer at that org.
Depends on whether they have one of the bosses that judge employees’ quality by the number of lines written.
> In my most other "industries", craftsmanship is not _dead_, but it's been pushed to the wayside for (significantly) cheaper and more available alternatives.
What if for a lot of software projects out there you don't need craftsmanship but you need something closer to real engineering: "This is what a sane PostgreSQL setup and transaction management for your app looks like, this is how you do validations and the ORM layer and logging and interaction with APIs and request queueing, this is how a good front-end page looks like, here's the off-the-shelf component library you use, here's how your process errors and show toast messages and handle redirects without messing around with browser history, here's all the accessibility and mean things you DON'T do (like hijacking scroll, not having contrast, having too many animations etc.)."
You don't have a rockstar building a bridge, nor do you usually have craftsmen taking risks on innovative materials and new approaches: most of the time, you just build the damn bridge in ways that have worked for decades and have been proven. Software industry doesn't seem to know what is proven or works, cause it's a moving target. Outside of maybe niches like writing code for airplanes, completely different standards there, not sure if most devs would personally want to work in those conditions, though.
Instead on one hand you have orgs and devs that are moving too fast and create a lot of churn without nailing down what works and doesn't, on the other hand you have a lot of people (myself included) that often have to push out slop because tech stacks are a mess and you still have deadlines which don't care about any of that, and largely the state of software development seems like a comparison between Windows 9X, the UI/UX of which was at least partially based on usability studies, and the modern version which... well, you can see for yourself.
I still remember times when my work was mostly cleaning and refactoring old code written just to have higher LOC by devs from India paid in cents per line.
They were creating fast like AI and so mich like AI. But they were merely humans. Cleaning this slow and buggy mess took years killed many companies.
Today we have AI and industrial quantity of code without any engineering skill involved in the process
Yeah, even though I like 'craftsmanship' here, stakeholders don't. I think "durability" is pretty good. 'Engineering standards' perhaps. I think we'll start to see the groundwork laid for software engineering as a proper engineering field, where specific performance characteristics are required for certain stakes.
Code can be like "heavy machinery", maybe needs license to operate. If an app has sensitive data in it, it becomes like a residential structure subject to building codes and inspections. I shudder to think of how this would play out it our oligarchic, anti-competitive environment though.
Hah. What a dream. Instead they’ll hire a team of what is essentially interns and have them deploy mass amounts of minuscule features with 0 guidance because, “hey - it’s cheap as hell and does 75% of what it’s supposed to do.”
A license to operate the code, what a trip.
To be frank, most other business units that are not tech or tech adjacent do not care about the code in the slightest, or the maintenance / security / durability of said code. It’s a tough world to live in. We understand the value of good code, maintainable systems, and proper design across the board. Relaying that to leadership who does not see the value is time wasted.
“What do you mean we need to rewrite it to adhere to engineering spec? It already works. Just deploy it to production”.
I don’t think we’ll ever be treated as engineers. We just had a non-technical person spin up a vibe-app that is now in production, real (measured, methodical, secure, spec driven, efficient) development is actively being devalued at my company and probably across the board…
Rant over. You propose a good solution I just can’t envision a future like this, there’s too much value in “barely good enough”, but perhaps the ramifications of that will eventually bring about your proposed future!
I don't think craftsmanship is dead, but I do think we've built a lemon economy.
The thing that creates the lemon markets is that you can't really distinguish quality until after purchase. This is extra hard with software because the average population is tech illiterate. It's even hard to distinguish when people are tech literate (and not all of HN is). Same thing with cars, most people can't tell the difference, so they buy based on price.
We kinda did this to ourselves. We pushed everything online and killed all the stores. Remember when no one would buy anything online because how risky it was? Then they created "free returns, no questions asked" and people would buy a few things and then send it back? That gave a store like feel with the convenience of home. So everyone moved online, the stores struggled to keep up, the Internet retailers kept running in the red (just like physical stores), the physical stores died, then the online sites needed to get a profit, so free returns stopped or diminished (or drove up the cost of goods. Yay arbitrage! It's like paying for credit card fees when you pay with cash \o/). So now everything is just worse.
We do similar things everywhere. We've started running the whole economy this way. By looking at it through a spreadsheet. Data is great, don't get me wrong, I'm an incredibly mathy person myself, but these are just proxies. To do good data analysis you also need to see beyond the math. To see where the proxy measurement isn't perfectly aligned with the desired measurement. How the measurement[0] can mislead you.
I hate how prolific this saying is. You can't know that you have all you need for your use case without first knowing more than you need. It's not something you asymptotically approach, you *have* to surpass it[1]. Without going beyond you, with no doubt, are just setting yourself up to live with unknown unknowns. It's absolute insanity that we say this bullshit with a smug look like we've discovered something profoundly intelligent.[0] all measurements are proxies. You can't measure anything directly. No, you can't measure a meter. You can measure a comparison to a meter stick. You can measure the time of flight of a laser. You can do all sorts of things like that but everything is always a proxy. If you think this just matters for high precision, well... just look at any house.
[1] an incredibly talented third party could get you exactly to where you need but now you've just doubled the people working
More like a lemon tree economy. We can still talk about which trees to pick in order to not get lemons.
> but anything built around long running business processes should not be treated in that way.
Arguably they are even more willing to cut corners though. Nothing by IBM or SAP should be considered "crafted", yet those companies have a strong place in the world of business today.
I like fixing code made by AIs and others (outsourcing code is similar as someone else said already). Last week we found out some client tried to vibe some departmental tool; the result is some massive crap in nextjs that needs 10GB mem to compile, has 1000s of lint errors, dev logs in git (very noisy ones) and so on. Now we have to fix it: its basically free 10k-50k euros over and over again for this type of work. Very easy if you know what you are doing; impossible if you don't. Keep m coming.
In some ways they are giving you a spec and UI mocks to implement.
This is one of the things I keep thinking about. At the very least, these tools make prototyping and idea vetting remarkably cheaper.
Then we go back to the old “the prototype works; I’m the boss and I’m telling you to deploy it to production”
There's like three groups of developers you need:
The prototypers, who move fast and break things, who throw together shiny first versions that look great and work some of the time;
The architects, who take the prototypes and take the time to build it correctly;
And the gardeners, who maintain the built system for the next 10-30 years, fixing bugs, making incremental improvements to speed or resource usage, and updating dependencies so that it continues to function on modern machines.
The crazy thing is that there are a ton of developers with different tastes who would love to fill each of the roles, but not many companies that are able to manage all three types without pushing everyone into one bucket.
Ha, I'm a gardener then, on my 15th year of maintenance. So halfway there according to you. Slowly, very slowly, fixing the thousands of bugs the rockstar left behind 15 years ago.
Prototyping is widely underappreciated. People think it's waste to throw away stuff but it's more costly to build upon shoddy foundations
The problem is those shoddy foundations can support a lot of weight before they finally fail. A prototype you write in a day - not a big deal to throw away. However if you have been working for a while that is a lot of effort/money.
Worse, often you need to spend years before you realize how an initial design decision was a mistake - not only are you proposing to throw away millions of dollars worth of work - you also don't know that your proposed better design is really better.
The day you implement the first edge case to your prototype you basically commit to using it forever or spending a lot of money to replace it.
Well, there's nothing as permanent as a temporary solution...
"So we all agree this is not ideal, but let's use it for now and focus on ..."
Heard it so many times.
But... "time to market!", "we won't have cash by the time this gets implemented properly" etc etc are the usual suspects here.
Sounds like valid issues to me. Pristine software isn’t the objective of most businesses. Leaving as a problem for another day, if we’re lucky that day will come, for many businesses, products, and startups it doesn’t and the shoddy prototype usually isn’t to blame.
I feel like SWE’s that make this gripe really need to step back and understand their role and the process for value creation. Because it’s certainly a process, the quality of code/architecture matters little if the low bar of functionality is met. Functionality can be sold to customers or used to test the market. It’s basically the whole MVP thing and the MVP should be a bit jank. If it wasn’t, you spent too much time/effort on it.
All said, there’s definitely some approaches to make it less jank from day one. Unfortunately, jankiness is a subjective metric.
It’s not about pristine software. Customers expect something that works. But changes will then be requested and the expectation is that the software will continue working. It’s hard to do that with janky code.
If you have a good architecture and keep good code hygiene, then velocity is easy. Without that, everything will slow to a crawl.
> If you have a good architecture and keep good code hygiene
That's a big "if" however - customers have a tendency to come up with requirements that aren't covered (or only covered in awkward ways) by the architecture you envisioned initially, while many of the well-architected parts will remain unused.
I agree, but I think you've not understood what the reply above is saying.
You will never get the chance of "customers requesting changes" if you never ship.
The company with the janky code that shipped will. And they will iterate and get better - as described by your process.
100% - one of the biggest advantages of software is its mutability, so why not use it to prototype properly?
I don't think I've ever not learned a better way to write something after writing it. Sometimes it's small and insignificant, sometimes it "forces" me to start over. The funniest is when more than half the code deals with something that won't happen. The banana that is not a fruit clause.
You can prototype UX with a tools like balsamiq or taking photos of paper sketches with paper-to-app application. No need for code to share an idea. Especially from business to engineering or vice-versa.
Product Managers coding is like Developers writing marketing pitches.
Why not? I've seen both sides working out remarkably well. It is much more of a mindset thing than anything else.
One of the major concerns with prototyping, at least in my experience and based on the general vibe I've felt from others over the years, is that clients will generally do some variation of "You have a working prototype? So how many days until it is prod ready? No more than a few weeks, right?" and that will be their expectation. AI makes prototyping easier, but makes this specific drawback much worse. Expectations are going to be misaligned, leading to many disappointments, and likely some number of developers taking undue negative outcomes. I'm not even sure if it will normalize to reasonable expectations, given that this tension never seemed resolved even before AI was in the mix.
This is a very interesting thought. We complain about having to fix some MBAs vibecpded slop, but it actually might be faster, easier, and alot less painful than getting them to try to explain their vision to us and implement what they have in mind.
Like they actually iterate on the UX alot when they are vibecoding things up, answer alot of questions that can onky be answered when you see an initial version of experience and realize something is off. Id rather they waste the clankers time with that than mine
This X a 1000.
I work in IR for small to medium sized business. The past few years have seen my business increase well beyond what I can reasonably handle and my bank account feels like a dragons pile of gold.
I will always always be on the side of security should be integrated and planned for and by no means do I want to see breaches.
That being said giving people of dubious expertise the ability to blast out an app in an hour has been an absolute windfall for me and others.
Agencies that focus on this sort of work are going to make bank. We’ve already gotten some work like this, and it’s just going to keep coming as people think they can vibe code their products. Like you said, easy money.
Lots of people are gambling on AI with big bucks. Some of it is promising but all those bets won’t pay off. I like to think of this mindset as being the human slot machine that people are shoving money into.
Are clients really paying for it? It’s really fascinating actually. Is it because the ”client” built it so they have sentimental value and sold it to themselves before you receive the request?
yep. exactly that
Did you use AI to rewrite it?
Hopefully, as the alternative would be leaving money on the table.
So how does one find these sorts of clients?
We have be in business for 30+ years; clients find us.
why fix it when you can just easily re-write/generate it from scratch?
That is also fixing… The client does not care about technical things so indeed rewrite is usually the best way even if we do not tell we did (people are proud of what they made so they do not want to just get told it was thrown away).
How much would it have cost to start from scratch?
Most devs will say less, but the reality is most of the time you build the wrong thing first, and the price you quote almost never gets what the client wants/expects and includes many overruns.
Every single contractor will say: that never happens when I do it...
This is a better solution for many businesses.
One, they already have a steaming pile of crap that kind of works. Forking that over to someone to "fix" for €10-50k is a steal - even if there's a decent chance they deliver nothing valuable.
You're talking about on the low end a few weeks of a dev's salary. You get next to nothing for that most of the time...
You could easily spend 4-5x that, take 3-4x longer and get something you can't use at all.
Happens all the time.
As some already said; the real win is into having a business driven prototype; the work to gather those specs is already done and, generally, very costly when done in the traditional way. So from scratch if having to do all of it is more expensive; technical from scratch far less so.
Interesting!
Yes, there's probably a market for vibe-coded software, but if there is, then there's also a market for fixing other companies' vibe-coded mistakes...
Phrased another way, you pay company A to vibe-code some software or extra software features for you, then you subsequently pay company B -- to fix company A's vibe-coded mistakes!
(Hey, look on the bright side! It's more money for taxes, GDP, employment ("jobs jobs jobs!"), and the circular Internet economy! :-) )
Some of this is also going to die out, if the prediction of price increases for LLM tools and tokens holds true. In that case a lot of this software essentially becomes abandonware overnight because the actual maintainer was Claude or Codex.
If you're a reasonably talented developers, I think there will be money to be made picking up projects left behind by coding agents. Maybe you'll use AI tools to do this, maybe you charge to migrate to other platforms and maybe you are paid to simply do bugfixes.
I'm sometimes puzzled by the way people use "circular" to describe an economic system pejoratively. (Not to suggest you are.) Seems like any worthwhile economic system is ultimately cyclical. Pulling resources into the loop is just a bonus....
> the result is some massive crap in nextjs that needs 10GB mem to compile, has 1000s of lint errors, dev logs in git (very noisy ones) and so on.
The anti-LLM propaganda is getting ridiculous at this point. No project "needs 10GB" to compile, unless you're working with astronomically massive repos, and _no_ LLM will _ever_ generate that. Lint errors (depending on cause) are either meaningless or a result of poor prompt engineering. If you want your project linted/formatted a certain way make it clear to the LLM.
Well, this is not the first project that has this. Depending what llm/harness and how it is yielded, this happens, a lot. How often have you had Opus 4.x note; ‘485 failed tests, but those are not related to my changes so I will not dive into them’? You believe someone who does not know about tests or code or linting or compilers will push back on that? I know that’s not happening for a fact.
>If you want your project linted/formatted a certain way make it clear to the LLM.
Most people have no clue what that means. Most Devs should know but I would wager that newer devs don't have enough opinion or exposure to do that.
I have approx 40GB of docker containers spun up at any time in order to run the app I work on, and it only seems to get hungrier by the day. I have absolutely 0 problems imagining a single unoptimized Next app needing multiple gigs just to run, yet alone compile.
Linting is also trivial for LLMs. I’d argue linting is one of the easiest and best use cases for coding assistants.
This story doesn’t add up.
You'd have to know what a linter is and tell the LLM to set it up though, right? Or just get lucky and have it suggest setting it up/set one up without asking.
The person running the Ai needs to know to set up linting in the first place and have it be applied. It's not a default.
Ive had ai make code that doesn't pass a linter and make code look like hand aligned code.
Shameless plug - I've been working on a general repo linting tool alint [0], which helps keep a repo cleanly structured and hygienic - essentially a linter for everything in a repo that a language-specific linter doesn't cover. It also has some considerations for integrating/playing nicely with agentic coding [1]. This started as a replacement to a bunch of scripts I had in repos that did similar things - but more cohesive, readable and much faster.
[0] https://github.com/asamarts/alint
[1] https://alint.org/agent-friendly-linter/
Oh sweet summer child...
Do you have any idea, even before modern LLMs, how much code out there was just given more memory instead of optimized? There are even good reasons for it (it can be cheaper than having devs spend time if there's more productive work to be had).
It can be very easy if said code needs to parse through gobs of data.
> No project "needs 10GB" to compile
You've never tried to compile NextJS slop, have you? It absolutely can take that much. All those junkdevs have 64GB in their MBPs for a reason. NodeJS max heap is now dynamic because of this.
The OP said that this was coded by a product person though. The product people coding and using these tools, who are spreading the pro-LLM propaganda, are not doing proper prompt engineering nor lint fixing.
> _no_ LLM will _ever_ generate that
Did you even read the post? Seems you are being overly hostile, defensive and dismissive. Honestly, you sound like an astroturfer to me. I'm curious to check your history to see if you match the vibe.
I've met a handful of people across my life that i'd call truly brilliant. Like, holy heck how in the world is this person this smart? Two things I've noted about really smart people are (usually mutually exclusively) 1) Sometimes they do not realize how smart they are, because it's simple to them, or because they know the subject they assume everyone else, say with a computer science degree, knows and recalls and understands all they do. I've had friends who go off on crypto related maths and I'm like "I passed that class, but know that I do not really know the subject you just talked about" ...
And 2) There's the people who it's painfully forefront of mind that they're smarter than most everyone around them. Some of them are jerks, some of them are exhausted by being surrounded by relatively "stupid" (again, relatively...) people. For the latter group i have some sympathy. Imagine walking through life and everything is clear, obvious, easy to process and having to watch humanity make stupid choices over and over and over again when the answers have been long known...
And then you’ve got a third problem - that well north of 50% believe themselves to be in that last sentence of yours
It seems that way sometimes but maybe we're just biased as we tend to hang out among intelligentsia
Oh we can call that the 4th problem. The bias of the people perceiving the bias
> Imagine walking through life and everything is clear, obvious, easy to process and having to watch humanity make stupid choices over and over and over again when the answers have been long known...
I don’t claim to be book smart or have a high IQ or whatever but I feel this way about small things that I feel are common sense. It’s maddening to me to watch people fumble around. Or do X when obviously it will result in -Y a bad thing. I really have learned to just not vocalize it, most of the time. It’s especially unhealthy for my close family relationships as I just see so much of it that I could nag them to death.
One of the things I try to teach my kid is: You are going to have to deal with the fact that there are deeply stupid people all around you, without it affecting your mental health. Those stupid people might be in a position of power over you, they might be other kids in school (or coworkers, later), they might be the president of the country, they might be your neighbor, or they might just be obstacles on the road on your way to work every day. You need to learn how to cope and accept this, gracefully deal with them, and how to protect yourself from their stupidity when it might affect you. It's emotional regulation that smart people need to learn or they go crazy.
i hope you don’t actually refer to these others as “deeply stupid people” to your presumably young kids.
Of course not. I'm translating for HN
The older I get, the more I realize that individual variation in humans is truly enormous. Any trait you could pick is much more widely distributed than any individual human can see from their perspective.
Just the other day I was watching a video on youtube, of someone absolutely struggling at a task that had a built-in checklist, verification steps, pictures, and basically (in my opinion) perfect guidance. This is something where, if I was doing it, I would just... do the steps. in order. and it would work, probably... 99.9% of the time, the first time, and relatively quickly, to boot.
I watched them fail to succeed like... 5 times in a row. At no point did they actually complete all the steps and verification in order. And this was a reasonable, intelligent, thoughtful, thorough person. They just could not follow a checklist, visual or written instructions, probably to literally save their life.
i feel fairly certain everyone has some set of activities or tasks they feel this way about
my wife and i have two non-overlapping sets haha you can imagine how that plays out
Same wrt my wife and I. She’s quite clumsy and to my assertion doesn’t always think things through. So it’s a bad combination for “accidents” to always happen which I think are very preventable and quite obvious to occur using her approach. A lot of it is just mental errors that I don’t make, but it’s not that I’m perfect I probably just make different mistakes (I think less volume too ;)
Yesterday she literally failed miserably at a single task. Her mission was grocery shopping. She drove to grocery store, shopped, and came home and left the groceries in the car. Didn’t realize it until she was making breakfast the next morning and there was no milk.
I see this two ways; 1) I would never make that mistake 2) I know her quite well, partners for over 20 years now, and this kind of thing is just her normal par for the course type of “oops”. The second part is what frustrates me the most, I like to learn from my mistakes and she treats it as a given that she’s just spacey/dimwit by nature and leans into everything being an “accident”. Obviously not healthy if I treat her like a child so I just watch her fumble through life and try to have a sense of humor about it all.
Yup, I've known and met such people.
However... NONE were "the 10x developer" who built up a huge mess. Which a team and I had to spend months and months cleaning up after.
The 10x developer believes deeply that they are #2, but they are usually incorrect.
I would say there are two explanations for group 2.
The first is that you aren't as smart as you think you are, because if you actually understood the people around you in any real way, you would instantly find them less frustrating. But instead you are using flawed heuristics, built out of your own insecurities, to interact with the world.
Possibility two is that you are smart, but you have developed a malformed coping mechanism whereby you take all your negative traits (social ineptness, anxiety, impatience) and treat them all as simple the nature outgrowth of your prodigious intelligence. This is a common coping mechanism, and the neat thing is, it has nothing to do with intelligence. You can be dumb as a brick and still feel like you're in a world of morons who are inferior to you.
In fact, I suspect these two explanations are one explanation.
> painfully forefront of mind that they're smarter than most everyone around them
Many devs choose to just do their day job or decide to follow a cargo cult.
Probably not every dev can have the same output, but if you decide to keep thinking beyond what is the cultural average, then everyone could be smart in their own way.
Most people don't realize they can do that.
It's lonely being an outlier, especially in a trait that's so fundamental to how you see the world. Despite best effort, it's hard to relate to most people, and they especially find it hard to relate to you. The delta of lived experience is quite wide, often insurmountable.
I feel like this could be said about most human traits, on both ends of those traits’ axis. I’m not sure if that makes it insightful or obvious :).
>on both ends of those traits’ axis.
I somehow suffer from both simultaneously!
Its never been quicker or cheaper to build something with bad foundational assumptions and principles. Its never been easier to add features whilst not recognizing that it comes with added responsibility. And it will never be too late to hire me for your V2 migration project.
These two sentences hit home:
> The flow of data was so hard to follow, it seemed like someone was trying to cover up a murder.
> Just getting the code to run on your laptop took a week.
I always thought I’m the only one having problem understanding the data flow, or setting up a proper dev environment. Impostor syndrome (and sometimes toxic environments that pushed for “velocity”) didn’t help either.
Felt good to know I’m not the one.
> Just getting the code to run on your laptop took a week.
This one surprised me. Claude Code in the CLI has made standing up an app and debugging whatever random dependencies or docker BS a dream compared to the before times, when you'd have to learn the architecture while simultaneously troubleshooting whatever isn't working on your machine
And in the before times, you learned a lot and walked away with knowledge on the deps needed, connections, .env secrets, and cleaned it all up and documented it so the next dev would have an easier time doing it.
Yeah, that totally didn't happen the majority of the time.
Yes it did. That's how I learned a great many things throughout my career. I'm sure some people didn't pay attention or try to understand what they were doing, and didn't learn. That's on them. But most of us learned a lot that way.
Bullshit I just pasted random shit from google in until it worked and then instantly forgot which combination of the 20 things I tried got it there.
Indeed, there were plenty of people doing just that. I imagine they get the most out of vibe coding. However, when it became a problem, an engineer was still required to fix it.
It might have been you, a couple of months later, or someone else. I have dealt with slop produced by unknowing programmers most of my career. With this vibe coding I think my job is still safe. The amount, though, is increasing exponentially.
I kind of envy people who need to clean up after others. At least you're puzzling.
My current job is genuinely just boring. It's tasks that are so simple, a junior could do it. But no, instead they needed a medior. I'm not saying I'm better than this, nor that no medior will pick it up. I just cannot push myself to care about the code this company makes. It's old, dusty and it serves no one of importance. These customers use it because they once bought the tool and do not care enough to switch, because the tool in question is not interesting.
I was promised work soon that aligned more with my experience, but I do not foresee these customers to come to a stale company like this.
It's not surprising that this company is losing customers, employees, etc. But I have a mortgage to pay. Today I had the conversation about how they might not extend my contract, basically threatening me to take more ownership, do more work, for the same pay. Sadly I have to make it last until I find a new position that is actually interesting. I don't even need a lot of money, I could give a rat's ass about "growing". I just need enough to survive.
This might be a very unrelated comment, in which I apologize. I just do not have another vent to post this to.
You are not alone. I was in this exact same position at MSFT and I put in my resignation. I am an L63 but the work I was doing, was something an L60-L61 could do and I frequently felt I was in one of those Bullshit jobs (courtesy of David Graeber). I was paid handsomely but once the sign on stock ran out, I saw that I was staying in the job just for security. I felt like one of those Hooli engineers who were sunbathing at the Hooli office terrace waiting for their stocks to vest. I am only 9 years into my career and I didn’t see that as the optimal thing for my career rn.
I didn’t have any major financial obligations like you though, so it was a much simpler decision for me.
Hang in there buddy and also thanks for the deeply human comment.
I learned in my 30s that most of the software profession works on boring projects. Uninteresting, low value code, for a barely-working product, used by customers who don't really care, in a low-stakes market that doesn't reward excellence, rigor, or quality. If you can find the rare company where this isn't the case, go for it!
> I am an L63 but the work I was doing, was something an L60-L61 could do
Maybe the problem is imagining that you need sixty three levels of granularity to describe experience or to establish superiority over sixty two categories of "lesser" engineers?
It’s not like the op invented Microsoft’s leveling system. It looks like junior engineer is 59 and 63 is something like senior engineer. I know at google there is a very meaningful difference in the work and responsibilities expected between our equivalent of 63 (L5) and 61(L4).
Believing in that system so much to say something like that might be worse. Noting against the OP, that kind of Stockholm Syndrome can be found in my past as well.
Not sure I understand. Is your contention that the distinction between senior and non-senior engineers is fake and everyone's doing basically the same thing? Or are you just objecting to the (arbitrary) names Microsoft uses for them?
Have no idea why people here are picking up on MSFT’s levelling system? I didn’t invent it.And it actually starts at L59.
The point I made was that as an SSE (L63), there’s a certain amount of scope and autonomy that is expected neither of which I was getting and hence I resigned. I am not trying to bully or denigrate anyone junior.
The levelling system specifies the output and the characteristics of the output expected out of an engineer, that’s it. Whether I believe in it or not is beside the point, I was in the system so I did believe it otherwise progressing through my career would have been impossible.
>Have no idea why people here are picking up on MSFT’s levelling system? I didn’t invent it.And it actually starts at L59.
Because it's standard arrogance by developers not realizing that Microsoft Level system is actually pay bands and because it was developed in 80s, leveling system COVERS all jobs because pay systems didn't support different pay bands back then. So there are lower levels then 59, for things like janitors, secretaries and others who don't make as much as SWE.
Entry-level software engineering at Microsoft starts at L59.
What a flex.
At first I thought "medior" was a strange typo for "senior", but on seeing it twice I had to check - apparently it's used in some parts of Europe to mean "mid-level"
It's a Spanish/Portuguese thing, so south America also. I kind like it even though I was originally nonplussed by the term.
Take a good look at the codebase you're working on. My guess is there's plenty opportunities to clean up after others, or even yourself.
> I just cannot push myself to care about the code this company makes.
I can very much relate.
Garbage products, by garbage companies, feeding on the laziness and tastelessness of most, as it's being capitalized by marketers.
And now, to make the matter worse - it's all being 100x by the LLMinazation of the entire field. Making code unmaintainable. And worse, making us all dumber.
I really wish we never have stumbled upon it.
> basically threatening me to take more ownership, do more work, for the same pay
I am a bit curious here. Does that simply mean to should to extra hours and do bullshit duties or is there actually more coding work opportunities? Or do they expect that you should prove more valuable out of nowhere?
I don't want to downplay your experience. In the latter cases, I wonder if you can actually do something.
I love this kind of comment. It's so human. Good luck, friend.
For a boring codebase how is your company not trying to throw tokens at it? Not saying its the right choice but definitely the trend I am seeing.
Perhaps they don't like slot machines
This is such a low value article lol
I'm not even sure what it's trying to say. It's just someone patting themselves on the back.
there is certainly code that sucks; but the article strikes me as someone conflating "code that sucks" with "code that is complex and big and takes a while to get used to".
I have found that a lot of the "massive amounts of bad code" left behind by "rockstar developers" is actually just a long slow drip of added complexity in the face of changing requirements. and I find that people think they're "refactoring the code for readability" when a lot of times, they are actually just "rewriting the code and therefore understanding it in that process".
tl;dr: "Slow down and think about what you're doing when using an LLM." Saved you five minutes.
I was expecting a lot more, or a worked example, or _something_ to that effect. 90% of the text is the author complaining and defining the problem, then a hand-wavy vague solution is presented in the penultimate paragraph. Barely relevant or useful, really.
Almost all opinion pieces are like that. They lack information density, but some readers (like me) like them that way. Otherwise, I'd only read one-line summaries.
I guess some people don't like articles that don't deliver a skill.md to solve a problem.
For me the article is about programmer culture and work ethics, it's hard to discuss with hard facts. Yet sharing this personal experience is valuable.
I mean, go look at the author's linkedin and github. They're a "dev" with 20 years of 1 year of experience. Not a software "engineer"
There's a big difference between the two and LLMs are increasing the chasm. The Software devs are crying out because the LLMs can already do their full job. Software engineers are happy because the LLMs are removing a large chunk of the job that's low value.
Software dev using an LLM is gonna produce "slop"
Software engineer using an LLM is going to have an increase in productivity depending on how they're using the LLM tools.
There is no universally accepted distinction between developer and engineer.
Even if so, dev or engineer, both can be low or high skill. Their job title doesn't tell how sloppy or good their LLM usage will be.
This isn't about distinction between literal titles. But continue missing the point.
You make up an false dichotomy. The differentiation between the title and the supposed skill level based on title, is neither true nor helpful to make your point.
Code that is written will have to maintained often by someone else than who wrote the code. So if one write code nobody else understands its an eventual maintenence failure.
You could optimize for different things. Code understandability by the team, speed, technical brilliance.
If you optimize for technical brilliance but nobody else on the team understands the code its still a failure.
Seen over engineered code
The first few sections hit me. I think that I used to be a “rockstar”, until I realized it wasn’t a good thing. Perhaps I could get things done 10x faster than my colleagues. But at some point I realized it wasn’t because I was 10x more productive than a normal person; it was that I worked in a way that made the normal people around me 1/10 as productive.
Since then I’ve slowed down. It’s been an overall positive change for my life. Being a team player unfortunately won’t give you the same kind of upward mobility in this crazy industry, but it’s done amazing things for my mental health.
I've definitely shot my own foot off in the past by implementing things in a rockstar manner. In my case, it typically involves me over-abstracting something that really doesn't need it. Or building something for use-cases that never actually happen. So I have to try to keep YAGNI and KISS in mind whenever my mind wanders into over-abstraction territory.
Copy paste is a very, very under appreciated tool when it comes to programming.
You can always abstract later, but once you start it’s terribly difficult to reverse.
I was such a fool to lean hard into two production engineers to build the infrastructure around the two very profitable projects I built. I could have made so much more money spaghetti coding it all like a 10x boss and then jumped to Anthropic for one of those sweet 9-figure comp deals. Stupid, stupid, stupid me.
At least that's my takeaway here.
This is where determinism is useful to help avoid these. A tool like Archiet does the determinism side of things and generates working solutions, which can then be given to a human or AI to sort out any gaps. This saves time, tokens and the need to clean up after AI rockstar developers.
Archiet also ships with the right architecture documentation, without the right architecture or specs-driven documentation, AI rockstars need clean up.
As much as it's true that a novice will generally use AI to build a sloppy mess, I've also had success unsloppifying through some careful prompting.
Yeah, v1 is sloppy, then I tell the LLM to clean it up. Every 1 prompt of building tends to require 1-5 prompts of clean up. Simple, fast, clean good code.
The chasm between "Software Developer" and "Software Engineer" is getting wider. Articles like this and the comments under it give away who is an Engineer and who is just a coder.
> Every 1 prompt of building tends to require 1-5 prompts of clean up. Simple, fast, clean good code.
I have found this to be very effective as well. However, it's so easy to do, I can't imagine they won't build it in.
The harnesses will improve and the loop of "self-review, judge what needs clean up, do the refactoring, repeat until clean" will get included in the one-shot. They are already doing this somewhat, they'll just get a lot better at it and as the models get faster and cheaper to run, the refactoring churn at the end of each task won't even create a noticeable delay.
I do not think the high-level "taste" knowledge that I've built up -- when to break something off into its own service, what to put in the DB vs cache vs queues vs blob storage, how to isolate important logic in pure functional layers so it can be tested and validated independently -- is any more "unlearnable" to AI than the stuff I previously considered impressive that's now one-shottable like "write a Prolog implementation from scratch".
They have definitely built some of it in.
And yes, right now you still need the architectural and system design knowledge because the LLM will fuck that up. We'll all find out if that continues being needed in the future. From what I understand about LLMs and how they work, I doubt it, but also, yeah, I doubted it would've gotten this far when I think back 2+ years ago.
Also, maybe I should be clear, I pretty much never one-shot things. My sessions with claude or other cli tools always starts with a bit of a conversation until we converge on a good plan, claude builds the code, we discuss some more, then we iterate.
The chasm is 1-5 prompts wide?
Knowing what you're doing holistically is the chasm.
The distinction between developer and engineer is obviously that one adds "make no mistakes!!!1."
I wish I had current-day AI (and a big credit card) for my previous job, they had a big legacy mess made by a productive but not very good developer, but my job was to rebuild it.
If I had AI tooling at the time I'd probably be more inclined to have it both refactor / optimize the existing application, add automated regression tests etc, and use it to extract all of the features and requirements for it for a potential rebuild.
But honestly I think if that application was properly designed and factored (instead of nesting JS in HTML in strings in JS or concatenating XML from query results only for it to be converted to JSON taking up 50% of response time) its lifetime could've been extended, especially if it was then containerized into a HHVM or similar php optimizer.
But, hindsight.
Any tips on how you unsloppify things? Are you using things like claude.md/copilot.md (or similar) to guide better, do you have specific types of prompts that you run, or do you adjust your code review practices in some way to more efficiently review lots of slop code?
One of my particular complaints is how code-gen LLMs tend to re-create the same code over and over again. Case in point, a use-case where a team name is generated from a list of team member names. The LLM re-generates this code in-line every time it needs to display the team name, rather than simply writing and reusing a utility style function.
I know I need to fix this. At this point I'm planning to just prompt something like "please list all the places where team names are generated/calculated", plus manually search through the codebase, then perform the abstraction myself. But I'm unsure how to prevent this (both this example, and other cases that could benefit from similar utility functions) continuing to occur in the future.
I accept that for every prompt of building I'm going to have 1-5 prompts of refinement.
Once the LLM tells me "Okay, it's done, everything works" I always as it to do a thorough review, I tell it to split up the work among sub-agents with each one taking on a specific responsibility (look for code smells, look for bad architecture, review the data access model, DUPLICATE CODE, testability and unit testing, etc.)
After a certain number of revisions and reviews you'll come to accept the shortcomings it comes back. Usually there will be specific design decisions you made that the LLM keeps bringing up, once the review only brings that up and maybe some other minor issues it's time to move on.
I don't overly rely on markdown files and directions. I don't rely on tooling around it either. I just don't trust the LLM when it says "all done", tests pass, and deployment works. I make it to multiple reviews and iterations even when it thinks it's done.
> Any tips on how you unsloppify things?
Understand what you're writing. If you never build up the mental model of what the code is doing you'll never be able to discern what is slop and what isn't. There are no shortcuts.
Piling more prompts on might get you to the same end result, but without understanding you'll never know when you're there.
Absolutely. I really don't think the future will be humans reading and picking apart an AI-generated codebase, there will be tech debt agents or whatever running overnight.
I think you misunderstand why tech debt lingers around. It's not a capacity or capability problem.
Organisations just don't want to deal with the accountability involved with "touching cold code". Whether it's a human or "AI agent" doesn't change the "It worked in prod, you touched it, you broke it, never touch anything again" dynamic.
Exactly this. When I reject a refactor PR (or ideally, _before_ there's a PR), it's not because it's a bad idea, per se.
But there's risk associated with every change, and it takes time to review, QA, monitor the rollout, communicate to stake holders, etc.
The refactor itself may be the smallest part of it.
That's one dimension of it, but in the context of this thread we are talking about how maintainable a codebase is for other humans. If your codebase is messy you depend on a few key employees and it might be hard to onboard new ones, so there has always been financial incentives to reduce tech debt.
> so there has always been financial incentives to reduce tech debt.
Yes. In practice, this does not weigh against organisational resistance.
AI really makes it worse by adding an explicit numerical cost to doing anything.
So your proposal to handle tech debt created by "AI" being unable to do good engineering is... throw more AI at it? There's a saying about the definition of insanity which comes to mind.
or linters
The ironic rockstar comparison is very good. The classic rockstar only cared about "new" technologies and wrote spaghetti code, the new 100x AI rockstar can do more damage.
It's a pity that the article ends cautiously with recommending to perhaps adapt AI usage practices. In this climate we are not there yet to publish the unfiltered opinion that generative AI is garbage and should be disposed of. Soon we will be.
I think this is fine? Code used to be very expensive to generate, now it is cheap. Building glue logic between well-defined, well-documented APIs has never been easier or faster. There is a time and place for throwaway code that quickly automates a task. It is fast food to fine dining -- not everything needs to be a Michelin star experience.
However, as always, AI usage is a matter of taste. Including your style rules in the prompt matters. Introduce new paradigms/tools/code into the main codebase because they solve a business problem, not because they are technically interesting. Careful development does not break 7 things to introduce one new feature, etc.
I think an important caveat is that LLMs are prone to writing unnecessary code, i.e. there's almost a superfluity to it, that at the same time makes it less straightforward and more prone to unnecessary side effects, which it does catch and handle, but that again expands code further.
Then you add an agent that goes through the code and simplifies it. Before every sprint, you get the agent to simplify whatever it can without losing fidelity.
It's really that simple.
"Just have a stochastic machine redo the code with no oversight"
This is an utterly terrible idea.
There's always oversight, that's just something you wrongly assumed.
One argument I heard from a college that the experimental llm written code (not production ofc) should be "write only" - you specify the requirements and constraints and let the machine figure it out - you specifically avoid "fixing it" or "cleaning it up" or reviewing the code because it disrupts the state of this discrete optimizer (over code). Not saying that it is right, or that it should be applied in prod, just noting that this is one potential way to go for non-critical code with clear "win conditions".
Oh, yeah.
I'm reconciling with the fact, that, if I let AI write a bunch of code, I have to depend on that AI to maintain it.
I just spent the last week, hunting down memory issues in the app I'm writing. I had a lot of help from an LLM. It rewrote most of the view controller that implements the map screen. That view controller is now 4,000 lines long (but half of that is comments), but it works extremely well. It took many context resets and rewrites to get here.
I would not have done it that way, but then, I probably also wouldn't have fixed the issue. The issue was really in Apple's MapKit, and I needed to do some gymnastics, to keep it from jetsaming my app. It's not particularly good code; but it works.
I've made the difficult choice to leave the sloppy view controller in the project, with the option of completely ripping it out, in the future, and replacing it with less "intense" code. It's pretty much "firewalled." It won't be that difficult to do it, assuming I have the bandwidth (and Apple finally fixes the memory hog issue, which seems to have been around for a long time).
There's all kinds of options that I could have (and still can) explore, but I feel that this is the best one.
But this article is absolutely correct. I think we will have a "slopocalypse," when it comes time to pay the piper for the thousands of vibe-coded applications that are certain to be authored in the next couple of years.
So far my take has been that there is code that isn't very important, in the sense that if it works it works, it won't be modified or extended much if at all, and it's easy to verify that it works as expected. This type of code I'm happy with letting the AI go wild on.
Then there's important code, like business logic, security related stuff and such. For that I'll happily use AI to brainstorm ideas and avenues, do code reviews where I'm prepared for it to be wrong and help with library suggestions etc, but where I want to write the code myself so I understand what's going on.
We'll see how it changes, been a wild ride so far.
I’ve never seen code that is unimportant. It’s either being used or not. If it’s boilerplate, it can be abstracted away. There are domains that are riskier than others (debug logging vs crypto for auth), but sometimes bugs in a somewhat safe place can lead to some catastrophic issues (you do not have to break a crypto algorithm if the key can be leaked via logging).
>Craftsmanship will always be in our hands, it's one thing we can never outsource to a machine.
Current AI coding is certainly very lacking in the craftsmanship department. But it is not obvious to me that that will always be the case. I don't think there's some fundamental reason AI could never produce code that matches or exceeds the craftsmanship of human experts.
The fact that LLMs fundamentally do not, and cannot, have understanding or reasoning. I don't think you can produce craftsmanship through sheer volume of throwing stuff at the wall and seeing what sticks.
Don't call them rockstars - call them "resume-driven developers."
We had one on our team in the past.
A bunch of microservices built on an in-house RPC framework he wrote, RabbitMQ, half-baked "monads" in an OOP language, esoteric naming, and no comments (the code should be self-documenting!), no docs.
Management adored him.
Once we started to grow, the problems started to appear: bad orchestration, uninformative logs full of PII, poor error handling, edge cases that were nearly impossible to fix within the existing abstractions, dependency hell, etc.
At that point, he moved on.
It took years and many hundreds of pull requests to clean it up.
Or people with not enough time, not enough resources and too much overtime already to kill off any happyness in creating the product.
This is why I always work at a new company at least 6-12 months before making any major changes. I use that time to get into the flow of how things are being done (even if I think they are not efficient). I may make some suggestions but that's it.
Of course, I'll probably never get hired again anywhere so it doesn't matter anymore.
In 6-12 months you could ship a new product or a large feature. This strategy might actually put you on a performance improvement plan instead.
A company/manager that would PIP you during onboarding doesn't understand the craft and does not deserve you.
Opening paragraph is not the profile of a rockstar developer.
At least not the rockstars I had the pleasure of working with.
I heard this kind of rockstar stories a lot from my friends but I never encountered one in real life. I worked in small and big companies and no one with allowed to use any obscure language or tooling. I count myself lucky.
You need a CTO to lay down the golden path.
.NET 4.8 only, vanilla JS only, MSSQL on-prem only, IIS only, no Azure ever.
I'll see myself out and return when I locate my "Developers, developers!" T-shirt, but I might find another job first...
Like many other critiques along this line, I think the answer is: Yes, for now. For example, in my own code base, I have an agent dedicated to maintaining a sane data model. This agent reviews the plan in advance and again during code review. And then I review the code myself. This seems to be sufficient for my work, at least. YMMV. It was a good post though. I enjoyed the take and the writing.
If you're reviewing the code yourself, then I don't think this article is about you.
I’m sure the general premise around AI-generated code is accurate. That being said, I’ve definitely had interesting moments where e.g. Claude produced code that matched the pre-existing codebase quite nicely, and slowly started building up its memory of how new pieces fit into the codebase in an idiomatic way. Then again, it started to throw in Tailwind-based CSS classes all of a sudden, because it assumed that Tailwind had been set up (it wasn’t).
Okay so "belt and suspenders" is an LLM-ism, it's not just me who recently learned that expression.
No that expression has been around a long time.
In the UK we call it 'Belt and Braces'
https://wordhistories.net/2018/12/13/belt-braces/
One thing I’ve found helps is leaning a bit more towards a modular almost microservice like model with clearly defined interfaces. Gives you a bit better control than a huge unified ball of AI spaghetti code
I don’t think the analogy between rock star developers and LLMs bears out here. Like any other tool, AI abides by the basic reality of garbage in/garbage out. If you don’t make sure the LLM has sufficient context then you get what you get. Same point with vague prompts.
AI tools are producing code on behalf of a developer. If that developer is fine putting their name on code that they don’t understand, applied to a code base they also don’t fully understand then you have a very human problem. The technology just magnifies this.
We are always the rockstar of someone else
Is the "Cleaning up after hundreds of AI rockstars" part a description of an actual experience? I don't feel that it is. I would expect much more swearing if it were the case.
It could be but there’s always been so called “10x developers” who just make 10x messes. I think it’s the continuation of an existing phenomenon.
https://www.tyleo.com/blog/the-terminal-star
This is a confusion that you could not have predicted, but primed by your comment, I expected "terminal star" to refer to a suggested predecessor of the AI rockstar. No, it refers to the animated Claude Code star :P
This was my take as well.
The post seems to not address the fact that different product phases exist which in turn affect the software. Similarly, teams are different and get assembled for different purposes. There is also a difference if software was created in the past 24 months vs past 10 years. It is very easy to attack decisions made which look messy now, because many reasons. Everything looks obvious in hindsight. And then making it ad-hominem like does not sound smart, it is a clickbait, the issues are usually more complex.
I did cleanup after rockstar diversity hires. I am lgbtq person of color myself, but that does not count since I have penis and European origin!
Sometimes I wonder if any of this will even matter in a few years. How many of us compile code and then have to clean up the assembly, or even worry about what a compiler generates as long as it's correct?
A great many people do that.
We are finding out that ram is neither cheap and unlimited.
I realized recently that this all has an unsavory element of ego to it. It doesn't help that LLMs have basically been trained to talk like they're performing in a movie, getting creative with techno-babble that sounds both plausible and exciting. I recently had to review some slop where the LLM was using terms like "event storm" to describe how some callbacks work, or "gating-solve" to describe a simple change to an if statement. Combine that with their sycophantic tendencies, and it really can make you feel like you're a star hacker in a Hollywood movie.
It reminds me a little of when Hegseth wrote "we're clean on opsec" in a message thread with confidential military information that he accidentally sent to a journalist. It seems like role playing/fantasy fulfilment for certain personalities. I struggle not to hold some contempt for people like this, who are making life difficult for everyone for their own petty reasons. I can sympathize when it's simple ignorance, but the ego chasing really is inexcusable and needs to be called out more.
Funny, the element of ego I'm seeing are the devs that can't accept that LLMs write perfectly good code at a faster pace. It's always "slop" this or "vibe coded" that. Meanwhile I've personally shipped multiple apps and professionally we've done HUGE things in these past 6 months using LLM tools.
Oh really? Link them.
Not sure what I'm going to link to in my professional life, it's all private repos. We have a large microservice architecture in AWS. We've made major changes and the LLMs have helped every step of the way. Migrated our whole auth system from being regional, resulting in customers being limited to specific regions or managing their multiple accounts across regions, to a global authentication with data residency built into accounts so that they login to what looks like a global app now. No more uk.example.com, eu.example.com, ca.example.com and us.example.com. It's now just example.com, but data residency (and currently data processing too, but that's another thing we're working on) stays the same. This isn't some small app, this is the main product at a company with nearly a Billion in ARR.
For personal projects, only one thing could I actually show - vaicayo.com
This app was originally started pre-llm. I just wanted a centralized place for my wife and I to organize our vacations. I built out the basic crud for that a long time ago and we used it, but then llms got popular. I first integrated it into the app, now I could get it to generate vacation plans completely with the llm. It did okay.
Somewhere between 3-6 months after building out llm features claude code released or I became aware of it enough to start using it.
I rebuilt the whole thing. So what was once a spring boot app running in AWS ECS with alb + cloudfront (and yeah, some sqs+lambda python processes, s3 buckets for storage, aurora rds for db) is now a super lean apigw + lambda + dynamodb stack with a svelte frontend. I went from paying $20ish a month to $0. I also built a flutter app for android and ios that utilizes the same backend as the frontend webapp with feature parity. It's not really a production app, but it could handle it fine, it's completely cloud native and hands off to operate. And let me be clear about the rebuild, it's not a 1 for 1, I think all that I kept was the domain model.
For features, it's mostly just a crud app. You plan your vacation in it. Outside of that there's the ability to take pictures with the phone app that auto-sync (there's a bit of complexity here, the phone app only syncs pics when it's on wifi unless you change settings to allow syncing on cell network, images are cached locally with a ttl, uploads will run in the background and queue up, uploaded images automatically resize/compress and generate thumbnails from an s3 event lambda). The other more complex item is email ingestion, when I get a reservation email I forward it to the app and it automatically processes it (the only place I use an LLM in the app right now). If it can't discern what the email is or which vacation it goes to it goes in a travel inbox so the user can route it to the right vacation and object type. Oh I guess the paywall is a little complex. I don't advertise this thing but I have left user registration open if anybody ever wanted to use it. I did lock the email parsing behind a paywall and I limit photo uploads for free accounts.
So frontend, backend apis, flutter app for android and ios all built 100% by llm.
For code quality, the frontend is okay, the backend is pretty clean but could use some things split out into domains, and the flutter app has some work to do (recently found a couple code smells). But there's no issues adding features, shipping, etc. I literally finished adding some of the photo syncing features in the flutter app last night.
Other than that, I have created 5+ other personal projects that I wouldn't have without an LLM. I've made 2 godot games, a private scribbl.io clone with a few extra features that myself and my coworrkers play as a "happy hour" on fridays, tons of ci/cd build stuff and terraform (using my own personal modules, so I guess that's not 100% llm coded if you consider the modules), and then a couple other simple apps.
The job when picking up a codebase made by human or machine always involves reverse-engineering the design intent from code. That's especially hard for LLM-generated code because the path to runtime was so rushed.
> It's more expensive to fix code at runtime than at compile time and at compile time than at design time. Unfortunately, AI rushes people to runtime as fast as possible.
https://www.slater.dev/2025/09/about-that-gig-fixing-vibe-co...
One of the things that annoys me is that we could know what the original intent was, and indeed the preferred form for modification: the prompt! Yet for some reason there's no standard/tradition/expectation that people commit all their prompting.
Perhaps I should start trolling people that your software is not truly Open Source if it's not Open Prompt.
> You can lead the engineering, and guide the LLM to generate small snippets at a time.
Yes, yes you can, but you can't force the LLM user to _understand_ your feedback so that they reduce the burden on you, as the reviewer.
This is why I like a bit of 'wet-kiss'es while working on projects.
In my opinion the problem rather is that most managers do not value elegance of the code, and most programmers are either too obedient or too clueless to dissent to management. Also, most team members don't want to understand highly elegant code and its inner beaty.
If management and teams would instead value highly elegant code structures over lots of "spewed out" code lines "that (superficially) implement a feature", I would bet that the problem discussed in the article would be much less of an issue.
I’ve cleaned up after outsourced code and it has a different flavor to AI rockstar code. In the former, you can see that the developer only care about the current ticket. After every merge, it’s a flurry of bug fixes, because they always break something unrelated. And that’s due to bad design, you will see a lot of copy pasted code and unused code.
As for the AI code, the most defining elements are unneeded complexity and low understanding of the abstraction involved. When you need a 10 lines functions, the AI will happily write an entire module because that’s how a fully implemented domain is like. But it’s not part of the requirements. As for the low understanding, you will see strange code, which are not fully antipattern, but are definitely not needed as it solves issue that the platform/library/framework doesn’t have or already have a solution for.
this resonates with me, but fortunately one difference between LLMs and rockstar developers, is that LLMs will at least _try_ to explain what they are doing, and why something has to be certain why. I've gotten quite a lot of mileage from being a five-year-old with Claude and just asking "why" until I'm satisfied
AI codes worse than even the most egotistic prima donna. I see future business opportunities in cleaning up the mess being created now.
I've said it before, I'll say it again, I'm convinced LLMs will be the thing to convince software engineers to get it together and create a licensing board.
Somebody wake me up when the ABET SWE PE is back.
That makes as much sense as having a licensing board for hammers or socket wrenches or welders.
"I am a rockstar developer and this characterisation is unwarranted" -- thought bubble emoji
> Half the code was written in a language you didn't understand. The other half was written using libraries you never heard of.
The author already describes himself as "not a rockstar developer", but if this is the definition of "rockstar" I need to recalibrate.
Being able to learn new languages and libraries, to me, is completely normal.
(Also: how funny is it to suggest rewriting code you self-admit you can't even read.)
There's a difference between introducing new things because they are a well thought out appropriate choice and completely ignoring the standards of the company because you want to do resume driven development. I believe the author is talking about the latter.
The point is that developers like this purposefully introduce new languages and frameworks that only they (and maybe not even they) fully understand, so they make themselves harder to replace and ensure that they appear ahead of the curve. (Then they get bored and leave anyway.) It's totally valid to introduce new technologies when the problem calls for them, but doing it in a way that's purely detrimental to the rest of the team is very selfish.
Just look at the author's accolades. They are very light.
I've never heard of this guy. He's "self employed"
The article lacks any real detail and it just a guy patting himself on the back.
Rockstars, AI or not, were 'successful' because they defined how success looks like. They created that perception and called it success. Not many people would bother going beyond the perceptions. They don't know how success or good code looks like. Rockstars gave them the playbook.
In reality, sometimes I wonder if there is really anything beyond perceptions.
Sure there is. Actually getting to the moon.
Story time! I Worked with not just a "rockstar" but what I suspect was a "superstar" for about three years at my last gig. It was a small company with about 3-4 developers at any given time and we worked on an embedded Linux product in a moderately safety-critical industry that had a messy ~25 y/o codebase and a custom, roll-your-own Linux distro on custom hardware. Our "superstar" had been with the company for ~10 years and due to really high turnover I was the most senior of the rest of the staff with 3 years. The manager of the software team claimed to have 10+ years of software development experience on his resume and LinkedIn, but would ask CS 101 questions in our software planning meetings.
The basic workflow adopted by our manager was thus:
You might think, with our superstar developer, a workflow like this would be possible. Honestly, I saw him do things (pre-AI) that were astonishing. He would work a weekend and add a feature I thought would take 2 weeks. He created a re-write of our main product and demoed a completely new product using the same hardware by himself in about 6 months. He would take feature requests not assigned to him and just do them before the assigned developer was even finished planning the feature. The sales team would come in with a pitch for an insane new feature idea (like add a Farsi version of the UI) on Friday, the rest of the team would attempt to push back on it, then he would check-in a semi-working version of that feature on Monday. For these reasons our manager loved him and would always ask the rest of the development team why we couldn't keep up. It was demoralizing and frustrating. At the same time, as a company, we were mostly unable to get very simple changes out the door. Most of the insane features we added died on the vine before getting to the customer (but the code would remain polluting the codebase). Any bug that was fixed would reveal 2 more serious show-stopping bugs. New software releases were regularly regressed: they would break one of our customer's use cases and because we never created basic functionality like OTA updates, we would fly a tech out with a flash drive to revert all the software. We worked on 3-4 new products an not a single one ever saw the light of day. Our company github was littered with dead, abandoned, duplicated repos.Basically our superstar developer absolutely allowed our non-technical management to commit software development seppuku. His successes were highly visible, but his failures were not:
I think about him a lot when I think about companies going all in on productivity maxxed vibe coded AI. I think that under better management that restricted his impulses and gave him more structure, he could have been a great asset to the company. Unfortunately when let run wild over the company codebase he was an absolute menace and ultimately led to less actual useful work getting done and an erosion of customer trust. I think this might be the reason we are getting two diametrically opposed experiences with AI: it is either going to destroy your codebase or deliver features at an astounding pace, and I think the difference is the actual technical knowledge of who is managing these projects. My guess is that there are a lot of places with middling or non-technical management pushing AI coding that are going to be in struggle city in a year or so and not understand how they got there. "But AI was making us so productive!".Nice Blog!
It’s literally no different than how to clean up old projects over the last 30 years of software engineering
I don’t understand why all this stuff is all of a sudden “new.”
It feels like we’ve got an entire generation of people who never had to spend their time factoring or doing hard infrastructure work
It’s actually pretty baffling how rare it is to find somebody who has consistent experience in refactoring that is under the age of 40
That's because the businesses got into the habit of new C level means new project, obviously the old code is bad.
I even had a PE buy the company I worked at, put in a new CEO, and his goal was to rewrite the entire code base in a year. I asked him what problems this would solve and never got a straight answer besides "its yucky" and "people told me they dont like it."
I have had multiple upper management teams decide that "dealing with this product is too hard, let's start from scratch" as if the new thing wouldn't have the same problems of the old thing, but with less effort put into it.
People love to work on new, all the possibilities and none of the bugs!(yet)
Yep, I worked at a small company that got bought by a bigger one. We had a solid if aging product to support which was one of the big players for the niche. Once there was a leadership change, 2/3 of the devs got put on building a replacement software. Then in a couple of years our subgroup got spun off and sold to PE and the v2 project was shelved for another brand new design to align with the new ownership. I left just before the spin-off, but witnessed how the original software slowly rotted away and all of the marketshare dominance we had for that area slipped away.
Devs love new tech and the product people love something new to put their stamp on, but chasing that high can be ruinous.
I think that’s actually the product incentive structure inside Google iirc
I think that’s right
I have seen over the past decades this concept of just reusable throw it away code becomes the norm and that’s why also I’m always surprised to look at people complaining about AI development and it’s like yeah it’s just the same as all other development at this point everything‘s just frameworks and throwaway code
I’m not even mad at it but it’s just one of those things where people are like “I’ve never dealt with anything like this”
But it’s the majority of operational software engineering since more or less forever
I think its also the pyramid of age - as you work in this field a lot of people burn out, the field was significantly smaller in the past and has shown huge growth, and the young say "yes sir!" and work nights and weekends on the fucking stupid idea while the older folks push back.
So in general most of the people have worked on a bunch of greenfield development, thought of the project 2 years old as aged out entirely, and never thought you might "maintain" something at all.
In my experience, this is because a modern engineering organization is laser focused on delivering value. Value rarely aligns with refactoring an existing, working implementation. If need the data, you build an integration on the output data. If something isn’t working well enough, you fix that one thing, you don’t refactor half the application.
Getting product to prioritize refactoring a working product is like pulling teeth. Even if maintenance is a moderate drain on resources, work beyond maintenance on working solutions isn’t seen as a net win.
It's different because LLMs can generate code that immediately needs to be refactored at speeds that were unfeasible before. There was a practical limit on the amount of technical debt that could be created in a day before, now that limit is 10x or 100x higher. It can be generated far faster than it can be fixed.
Then code factoring was never the key problem was it?
It was organizational discipline
Again this is the same problem previously…organizational lack of discipline means you get some diva to build some un maintainable thing and then you have to go back and refactor it later
The problem is the same the speed is different I acknowledge but both our organizational problems and have nothing to do with writing code or technical
If a neighbor leaves their dog's poop in my yard I have a problem. If someone builds an industrial scale dog poop delivery mechanism that delivers tons of dog poop to my yard every day I have a different problem even though the underlying basics are the same.
The problem in isolation isn't new as such, but I think there's a combination of new factors to differentiate it:
1) the speed at which AI-generated codebases grow is far in excess of what human developers can achieve. What took years to accumulate in the past can be produced in a few days/weeks.
2) past large codebases that end up in a similar state would often see a mixture of developer talent. So while you might have a few developers who produce dross, there will also be a few who can pull it back together. You start to see threads of sanity appear, and from that the potential to refactor further, rather than the uniform spaghetti monster that's near unassailable from every direction that we're now getting from the pure-AI projects.
3) external perception differs. AI has been pitched, sadly by sales, influencers and shills rather than experts in the field, to business leaders as the solution to all development problems. When you present this issue to stakeholders you're then immediately put on the defensive, e.g. it's initially viewed as negativity for the sake of negativity. With past technical debt discussions, outside of a few key parties (too often the person responsible for overseeing said debt developing), I've found that it's relatively straight forward to explain technical debt, the need to refactor and maintain systems as a going concern. For the technically disinclined it's easy to draw parallels with building maintenance: you don't expect to build an office and then never spend another cent, it takes continued investment and maintenance to keep it safe, clean, functional and compliant. The difficulty again with the AI projects here I think comes back to the accelerated timeline, as you're inevitably going to be saying months after it's created that it probably needs to be burnt to the ground in lieu of the far greater task of refactoring it. As opposed to a legacy project that has been going for years or decades, where it's a far more palatable concept to take drastic action.
You're just witnessing "Software Developers" cry out over LLMs.
"Software Engineers" are embracing LLMs and getting shit done same as before.
> how to clean up old projects
What’s “new” is indeed the “new” bit in cleaning up new projects.
> Building software that lasts
Nah. Now everyone can build single purpose, single use, throw away software.
Then reconstitute it later, even if slightly different. Nobody cares because it's small.
The photo in the article looks like AI slop but isn't - it was taken in 2019. It took me awhile to convince myself everything in it was real.
If you're just starting to learn programming, people will tell you that maintainability is important, and they'll mention John Ousterhout's concept of the "tactical tornado" as an anti-pattern.
The problem is that this approach implements features quickly but in a way that conflicts with the team's mental model, ultimately ruining the entire codebase.
A lot of blog posts initially framed this as a problem. I agreed to some extent.
But as I've gained more programming experience, I've come to realize that all programs degrade over time until they are reborn. Eventually, it seems that destructive innovation is necessary for longevity. And sometimes, new patterns emerge from that kind of disruptive feature development.
So you could say that AI rockstar developers and AI-driven development are close to being a "tactical tornado" because their codebases are bad, with poor maintainability and reliability.
Maintainable development, in my experience as a traveling contract developer, usually refers to code that is well-modularized and well-crafted, making it easy for someone like me to understand the codebase when I come on board. But when I saw the leaked Claude code, frankly, the code quality was disappointing—yet by my standards, it worked very well.
So I've changed my mind lately. I think we actually need a new classification of developer types: those who love creating new things but are bad at maintenance, versus those who are conservative, good at maintenance, and build beautiful code.
What makes me think not too badly of recent AI-Rockstar(or AI vibe)developers is that as any industry becomes more advanced, it becomes harder for stars to emerge. Work gets divided and specialized, and no single individual can master everything. For example, I'm confident in writing 60,000–90,000 lines of code by combining frameworks based on IoC (Inversion of Control). But I'm weak at large-scale programming like distributed systems or low-level programming. That's the difference in expertise. I'm strong at the macro level but weak at the micro level. You become cognitively optimized for your own domain.
vibe coding developers(or AI star developer)since AI is still far from being highly advanced—produce messy code, but they definitely bring a new kind of shock. And when you look at their internal structure, many developers mock them. This reminds me of Undertale. Undertale's code is full of if statements and an enormous number of branches—honestly, it seemed like the developer didn't even know the basics of coding. Yet that game became a historic success. The same goes for programming. Some people make the code components beautiful and efficient, while others focus on delivering what the end consumer wants.
So these days, I even think that the more AI developers create bad software using AI, the more new jobs will emerge to maintain that software. Everything always has two sides, it seems.
And in a way, maintainability means knowing how that feature fits into the overall shape and UX of the product. With new products, that prediction is often impossible
I believe GNU Emacs was created in 1984 or 1985, and it's still going strong. I guess it's not easy to work on it due to the long history, but I understand it's been refactored as the developers went along.
I think those people are great. They work silently behind the scenes for the sake of others.
Please write a manual on how to cleanup after AI rockstar managers who think they can code.
Much needed right now as I slept only two hours since yesterday after solving a SEV-0 and having to wake up after a 2 hour nap, so I could be now cleaning up the fallout before business hours.
I am not a AI-denier, I am actually thankful I have AI right now to multiply my force, but frankly, people STILL need to review that fucking code, and the people who review the fucking code STILL need to be good enough to be able to write it themselves if they needed.
Whoever says otherwise is either an AI investor, a linkedin influencer or a complete imbecile.
--- EDIT
Please add a section on how to communicate and write a post mortem where the guilty is completely exhonerated without the blame falling on me as I try to save said manager's face.
> Please write a manual on how to cleanup after AI rockstar managers who think they can code.
Why are you allowing AI rockstar managers to (I assume) push without code review? Why are you cleaning up the fallout? It's not AI issue, it's people issue
It's the mandate from top-down. Of course it's a people issue, the problem is that the people creating this issue are exactly the ones paying us.
My manager got the mandate she needs to start coding, she doesn't want that, no one in our team wants that, she's a great manager exactly where she is right now. Nonetheless, we are helping her to code to show something for the higher-ups so she can keep her job, we really don't want to lose one of our best managers because some C-level is anxious about AI...
Even if it's a mandate top-down, you can:
- show increase in errors and outages caused by this approach
- integrate manager changes into your CI pipeline (coding / reviewing / testing / documentation)
- discuss how your manager can do the changes they need to do without sidetracking all other work
Make it indeed about the money: coding by PM + fixing what was coded + dealing with fallout is greater expense than coding by PM + automated guidelines + reviewing what was coded.
That is - if the environment you're working in is reasonable and it's not a power play by your PM
I don't know why you assumed it was a PM thing, the mandate is for EMs to be more "hands-on".
On your points:
Manager changes are always going to go through the usual pipeline, we are 10k+ people so there's not even a way to go all gung-ho pushing stuff. They need to be reviewed, approved, etc.
But we don't want our manager to code, nor does our manager, so we are just helping to cross the bare minimum expected from higher ups. For my team it's not an issue with our manager's code (those will be at max small fixes, well-defined, the most trivial stuff), the issue is they are mandating managers to do it.
I don't know what size of company you work at, where I am at there is simply no incentive for me to do all the extra work to show execs/higher management the issues cropping up.
I don't even have access to them, I have to pass through other channels, those might compile reports from many people to try to present a case, if they get to present a case then there's a whole other discussion to happen at director/VP/C-level about what they want to do, and since it goes against their big mandate it most likely will just be thrown out.
In this structure I have no motivation at all to go out of my way to perform data gathering/analysis, wrapping it all in a nice concise document explaining what the data means, potential remediation, etc. just to become a footnote in someone else's document that ultimately will not change anything from the VP/C-level mandate.
I assumed that as it was hitting too close home (both PMs and EMs were expected to use AI, with PM trying to code in solutions that they didn't have expertise nor domain knowledge to deal with; EM was prototyping solutions that had access to prod DB that were shut down as soon as we found out). I can only symphatize nonetheless and thank you for giving your PoV.
Because most people, in most parts of the world, are not allowed to question whatever their superiors do? And, yes, unfortunately are also expected to clean up after said superiors' messes. Of course it's a people issue. AIs just make people issues worse in new and entertaining ways.
The code is AI reviewed, and I was ordered to change repo setting so a single AI review is enough. I've tried suggesting a lot of things, but it is not on my paygrade to allow or disallow something, only recommend.
100%. You don't "clean up after them." You make them clean up their own mess. You refuse to let a mess into the system in the first place.
Same as it ever was.
The only difference now is that if you let it happen, it'll happen 100x as fast.
When I was mentoring junior devs, I would start by fully reviewing their code. If they had a ton of mistakes more than a few times, I would only review until the first mistake, and then reject it. Repeat, repeat, repeat, until they got the picture that I wasn't going to let mistakes through, and handing me a ton of mistakes was going to waste more of their time than mine.
I let the pain be their pain, instead of mine.
But good developers, I'd help them by doing a more thorough review and not wasting their time. Good developers were the ones that made an honest effort to follow the requirements to the letter and test their own work.
We further emphasized this by having a very simple coding test during the interview, and the only thing we cared about was whether they followed the requirements to the letter. There wasn't a lot left to the imagination, and the requirements were very clear. Anyone who missed them wasn't someone who would do well with us.
That very same test will help filter out a lot of AI-braindead candidates that don't check the AI's work as well.
Actually, I wish I still had the exact test so I could throw it against an AI and see what happens. I'm a little afraid that it would pass it too easily now. I'm not sure how I'd fix it to prevent them from just using AI.
No, no, much better: make it a SKILL.md ;)
I run a whole ass month long class on exactly this
It’s actually not much different than a decade ago cleaning up somebody else’s giant Visual Basic or PHP spaghetti code that stuck on the wall
30 odd years ago this post would have been titled "Cleaning up after compiler generated assembly" ...
Hmm, ~30 years ago the compilers that I was using were generating generally fine assembly/machine code. Some of the other tooling was more troublesome: cross platform high performance numerically stable code and C++ static template deduplication paid for a lot of beers around then, and I needed them.
thank you my elder statesman .. i hallucinated .. maybe ~40 or ~50
Compilers are deterministic and they actually possess domain knowledge of what they are trying to do. AI models are non-deterministic, have no real domain knowledge due to lack of an underlying world model, and their way of "writing" software is to spew out something that looks like something that they have been trained on, then iterate on it long enough until it has reached the level of being barely runnable.
good, "this underscore user". stay in that lane.
AI is absolutely deterministic, just as much as a a car is, with a human driver (who is also soon going to be replaced with AI anyway) .. I ship more, fix more bugs, audit my code for security more and thoroughly enjoy not just the process of building, but also the asymmetric power i wield by out executing my well funded competitors with 100 developers and 10 testers dnd 5 devops and 10 full time sales staff.
I don't think you know what deterministic means
Indian dev culture
Nah man that's not it
Rent free.
I don’t thing you know what being in denial means ;)
Sure, dude lol
If you actually did this work, you'd know that code is cheap, and it's figuring out what to build that's hard. And then selling it, too.
i'v got some openings in case you need a job bud
actually wait, claude code single shotted yo crappy wedev career bye bye lol
Bet. Link it lol.
> Half the code was written in a language you didn't understand. The other half was written using libraries you never heard of.
> As you waded through the slop, you browsed job postings and fantasized about leaving
Just because you didn't understand something or haven't heard about a library, doesn't mean its slop. How do you make sure your definition of "clean code" is not a slop to others?
I'll avoid trying to guess what the author meant, but I found it rather relatable. Some of these "rockstars" pick weird languages, niche database, esoteric frameworks and whatnot, not because they're needed, but because that's the rockstar thing to do at that moment. And then they leave and you're stuck managing a Cassandra database and a Rust application when everything else around you is MariaDB and Java, and you have to maintain an application in an abandoned JavaScript framework, even though dynamic frontend wasn't a requirement.
This is a guy who has 20 years of 1 year of experience. His blog includes his linkedin and github, just give it a look over.
Programming is for humans first. Cleanness and code quality is judged according to that.
This isn't a problem with "rockstar" AI devs. This is a problem of management. Who would let someone come in and rebuild the core infra of their business without any planning or review?
This article feels is trying to justify their own inefficiencies (lack of library or language knowledge) instead of taking the time to learn from the rockstar and their technology choices.
As I was leaving my last job, I advocated everyone migrate from plain old es6 to typescript, b/c several times broken builds made it to production.
Certainly my coworkers may of felt upset that typescript is too verbose and pointless if everyone reaches for the "any" operator. But that doesn't mean the decision to move to Typescript was bad, it just means the company is "old school" and not willing to take the time to adopt modern workflows...
> Sometimes there's so much technical debt that it can never be paid off.
There is no such thing as technical debt in the age of AI. It's just a series of migrations that take minutes to come up with.
I migrated from two disparate databases using AI and it took minutes for it to write the migration code. I had it double-write the data, and then I told the AI to write code to compare between the two databases, and I then tested over the course of a week.. I fixed some small bugs, or more precisely I told the AI to fix the bugs and it did.
Then once I was satisfied, I switched it so that the new database was primary and the previous database was secondary. Then I tested to make sure the data was still in sync. Then I switched off the previous database, then I removed all traces of the previous code.
It was simple and relatively quick. The thought that there exists technical debt in this age is absurd. One person can do things an entire team used to take in a fraction of the time.
> There is no such thing as technical debt in the age of AI.
Producing new technical debt quickly doesn't mean there's no more technical debt.
Never mind the huge, untouched, unspoken-of debt to all the people whose work--literary, artistic, software--under various licenses, or without, it (rather THEY, the owners and co-conspirators) are taking and re-using, without attribution, without credit, nor payment of any form. Not even a thanks (because as soon as that is acknowledged it will enter the consciousness and then the question of injustice will dwell--and we can't afford to have people thinking about that).
Thanks.(plays world's smallest violin)