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.

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.

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.

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.

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 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.

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?

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"

[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

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 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.

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.

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! :-) )

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.

A "Report" is just a document feature projection.

People may initially think this is in err, then think again... =3

Not sure what that proves.

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

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.

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.

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!

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.

In the UK we call it 'Belt and Braces'

https://wordhistories.net/2018/12/13/belt-braces/

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.

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.

"Software Engineers" are embracing LLMs and getting shit done same as before.

What’s “new” is indeed the “new” bit in cleaning up new projects.

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 really that simple.

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.

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.

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.

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

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.

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.

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.

https://www.tyleo.com/blog/the-terminal-star

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)

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".

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.

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.

This is an utterly terrible idea.

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.

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.

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.

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

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.

You can always abstract later, but once you start it’s terribly difficult to reverse.

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.

Perhaps I should start trolling people that your software is not truly Open Source if it's not Open Prompt.

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.

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.

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

Then we go back to the old “the prototype works; I’m the boss and I’m telling you to deploy it to production”

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

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".

my wife and i have two non-overlapping sets haha you can imagine how that plays out

Devs love new tech and the product people love something new to put their stamp on, but chasing that high can be ruinous.

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.

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.

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.

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.

I somehow suffer from both simultaneously!

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.

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.

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 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.

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.

Yes. In practice, this does not weigh against organisational resistance.

AI really makes it worse by adding an explicit numerical cost to doing anything.

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.

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.

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.

Product Managers coding is like Developers writing marketing pitches.

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.

If you have a good architecture and keep good code hygiene, then velocity is easy. Without that, everything will slow to a crawl.

Heard it so many times.

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.

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.

Why does good code imply never shipping?

Managers and Developers have different thresholds for “good enough to release”. The former are not the one on call for bugs or the one that get blamed for outage, but they are the ones that get praised when projects are completed quickly. Anything that’s past demo level is good for them.