News for hackers. Stuff that matters.
Re:Writing Code Was Never the Bottleneck by dizhn on Thursday July 03, 2025 @06:16AM (#44453468)
> - Many bugs were of a new kind (to me), the code would look like it does the right thing but actually not work at all, or just be much more broken than code with that level of "polish" would normally be.

This reminded me of a quarter million dollar software project one of my employers had contracted to a team in a different country. On the face of it - especially if you go and check by the spec sheet - everything was there but the thing was not a cohesive whole. They did not spend one second beyond the spec sheet and none of the common sense things that "follow" from the spec were there. The whole thing was scrapped immediately.

With LLMs this kind of work now basically becomes free to do and automatic.

Re:Writing Code Was Never the Bottleneck by Sammi on Thursday July 03, 2025 @06:41AM (#44453628)
I'm expecting to see so much more poor quality software being made. We're going to be swimming in an ocean of bad software.

Good experienced devs will be able to make better software, but so many inexperienced devs will be regurgitating so much more lousy software at a pace never seen before, it's going to be overwhelming. Or as the original commenter described, they're already being overwhelmed.

Re:Writing Code Was Never the Bottleneck by conartist6 on Thursday July 03, 2025 @07:48AM (#44454040)
Yes, but some of us have seen this coming for a long time now.

I will have my word in the matter before all is said and done. While everyone is busy pivoting to AI I keep my head down and build the tools that will be needed to clean up the mess...

Re:Writing Code Was Never the Bottleneck by distalx on Thursday July 03, 2025 @08:07AM (#44454161)
Any hints on what kind of tools you're creating for the inevitable mess?
Re:Writing Code Was Never the Bottleneck by conartist6 on Thursday July 03, 2025 @08:22AM (#44454263)
https://github.com/bablr-lang/

I'm building a universal DOM for code so that we should see an explosion in code whose purpose is to help clean up other code.

If you want to write code that makes changes to a tree of HTML nodes, you can pretty much write that code once and it will run in any web browser.

If you want to write code that makes a new program by changing a tree of syntax nodes, there are an incredible number of different and wholly incompatible environments for that code to run in. Transform authors are likely forced to pick one or two engines to support, and anyone who needs to run a lot of codemods will probably need to install 5-10 different execution engines.

Most people seem not to notice or care about this situation or realize that their tools are vastly underserving their potential just because we can't come up with the basic standards necessary to enable universal execution of codemod code, which also means there are drastically lower incentives to write custom codemods and lint rules than there could/should be

Re:Writing Code Was Never the Bottleneck by mdaniel on Thursday July 03, 2025 @08:59AM (#44454565)
Who is the consumer for the JSX noise that is happening here? https://github.com/bablr-lang/language-en-ruby/blob/550ad6fd...

As two nits, https://docs.bablr.org/reference/cstml and https://bablr.org/languages/universe/ruby are both 404, but I suspect that latter one is just falling into the same trap as many namespaces make of using a URL when they meant it as a URN

Re:Writing Code Was Never the Bottleneck by conartist6 on Thursday July 03, 2025 @09:10AM (#44454664)
We're cleaning up the broken links as time goes on, but it is probably obvious to you from browsing around that some parts of the site are still very much under construction.

The JSX noise is CSTML, a data format for encoding/storing parse trees. It's our main product. E.g. a simple document might look something like `<*BooleanLiteral> 'true' </>`. It's both the concrete syntax and the semantic metadata offered as a single data stream.

The easiest way to consume a CSTML document is to print the code stored in it, e.g. `printSource(parseCSTML(document))`, which would get you `true` for my example doc. Since we store all the concrete syntax printing the tree is guaranteed to get you the exact same input program the parser saw. This means you can use this to rearrange trees of source code and then print them over the original, allowing you to implement linters, pretty-printers, or codemod engines.

These CSTML documents also contain all the information necessary to do rich presentation of the code document stored within (syntax highlighting). I'm going to release our native syntax highlighter later today hopefully!

Re:Writing Code Was Never the Bottleneck by lsaferite on Thursday July 03, 2025 @08:38AM (#44454400)
Where does this "universal DOM for code" sit in relation to CSTs and ASTs?
Re:Writing Code Was Never the Bottleneck by conartist6 on Thursday July 03, 2025 @08:56AM (#44454537)
It's an immutable btree-based format for syntax trees which contain information both abstract and concrete. Our markup language for serializing the trees is Concrete Syntax Tree Markup Language, or CSTML.
Re:Writing Code Was Never the Bottleneck by LtWorf on Thursday July 03, 2025 @08:23AM (#44454275)
A faster command to recursively unlink files.
Re:Writing Code Was Never the Bottleneck by bbarnett on Thursday July 03, 2025 @07:46AM (#44454023)
I'm waiting for someone to use an LLM to handle all AWS deployment, without review, and eventual bankrupcy as the result.

Even better if the accountants are using LLMs.

Or even better, hardware prototyping using LLMs with EEs barely knowing what they are doing.

So far, most software dumbassery with LLMs can at least be fixed. Fixing board layouts, or chip designs, not as easy.

Re:Writing Code Was Never the Bottleneck by belter on Thursday July 03, 2025 @08:34AM (#44454356)
AWS itself is currently polluting their online documentation with GenAI generated snippets...I can only imagine what horrors lurk on their internal code base. In a move similar to the movie War Games, maybe humans are now out of the loop, and before a final commit LLMs are deciding....
Re:Writing Code Was Never the Bottleneck by oytis on Thursday July 03, 2025 @08:19AM (#44454246)
There are ways to fight it though. Look at Linux kernel for instance - they have been overwhelmed with poor contributions long before LLMs. The answer is to maintain standards that put as much burden on the contributor as possible, and normalizing unapologetic "no" from reviewers.
Re:Writing Code Was Never the Bottleneck by gyesxnuibh on Thursday July 03, 2025 @08:35AM (#44454373)
Does that work as well with non-strangers who are your coworker? I'm not sure.

Also if you're organizationally changing the culture to force people to put more effort in writing the code, why are you even organizationally using LLMs...?

Re:Writing Code Was Never the Bottleneck by aleph_minus_one on Thursday July 03, 2025 @09:39AM (#44454953)
> Does that work as well with non-strangers who are your coworker? I'm not sure.

Simply hire people who score high on the Conscientiousness, but low on the Agreeableness personality trait. :-)

Re:Writing Code Was Never the Bottleneck by oytis on Thursday July 03, 2025 @08:45AM (#44454451)
> Does that work as well with non-strangers who are your coworker?

Yeah, OK, I guess you have to be a bit less unapologetic than Linux kernel maintainers in this case, but you can still shift the culture towards more careful PRs I think.

> why are you even organizationally using LLMs

Many people believe LLMs make coders more productive, and given the rapid progress of gen AI it's probably not wise to just dismiss this view. But there need to be guardrails to ensure the productivity is real and not just creating liability. We could live with weaker guardrails if we can trust that the code was in a trusted colleague's head before appearing in the repo. But if we can't, I guess stronger guardrails are the only way, aren't they?

Re:Writing Code Was Never the Bottleneck by sarchertech on Thursday July 03, 2025 @09:22AM (#44454781)
I don’t want to just dismiss the productivity increase. I feel 100% more productive on throw away POCs and maybe 20% more productive on large important code bases.

But when I actually sit down and think it through, I’ve wasted multiple days chasing down subtle bugs that I never would have introduced myself. It could very well be that there’s no productivity gain for me at all. I wouldn’t be at all surprised if the numbers showed that was the case.

But let’s say I am actually getting 20%. If this technology dramatically increases the output of juniors and mid level technical tornadoes that’s going to easily erase that 20% gain.

I’ve seen codebases that were dominated my mid level technical tornadoes and juniors, no amount of guardrails could ever fix them.

Until we are at the point where no human has to interact with code (and I’m skeptical we will ever get there short of AGI) we need automated objective guardrails for “this code is readable and maintainable”, and I’m 99.999% certain that is just impossible.

Re:Writing Code Was Never the Bottleneck by gyesxnuibh on Thursday July 03, 2025 @10:25AM (#44455393)
My point in that second question was: Is the human challenge of getting a lot of inexperienced engineers to fully understand the LLM output actually worth the time, effort and money to solve vs sticking to solving the technical problems that you're trying to make the LLM solve?

Usually organizational changes are massive efforts. But I guess hype is a hell of an inertia buster.

Re:Writing Code Was Never the Bottleneck by oytis on Thursday July 03, 2025 @05:12PM (#44459239)
The change is already happening. People graduating now are largely "AI-first", and it's going to be even worse if you listen to what teachers tell. And management often welcomes it too. So you need to deal with it one way or another.
Re:Writing Code Was Never the Bottleneck by exe34 on Thursday July 03, 2025 @08:47AM (#44454466)
> Does that work as well with non-strangers who are your coworker? I'm not sure.

I imagine if you have a say in their performance review, you might be able to set "writes code more thoughtfully" as a PIP?

Re:Writing Code Was Never the Bottleneck by bluefirebrand on Thursday July 03, 2025 @09:54AM (#44455125)
No, because that's not measurable
Re:Writing Code Was Never the Bottleneck by exe34 on Thursday July 03, 2025 @01:57PM (#44457595)
It's measurable in the number of times you have to spend >x minutes to help them go through something they should have written up by themselves. You can count the number of times you have to look at something and tell them "do it again, but without LLM this time". At some point you fire them.
Re:Writing Code Was Never the Bottleneck by andreasmetsala on Thursday July 03, 2025 @05:06PM (#44459193)
That’s not measurable either. Your opinion on someone is not data.
Re:Writing Code Was Never the Bottleneck by exe34 on Friday July 04, 2025 @03:21AM (#44461988)
My opinion on someone is how I decide whether I want to work with them and help them grow or fire them/wait for them to fail on their own merit (if somebody else is in charge of hiring/firing).
Re:Writing Code Was Never the Bottleneck by belter on Thursday July 03, 2025 @08:29AM (#44454313)
Please, somebody make the Is MongoDB webscale? video for LLMs...
Re:Writing Code Was Never the Bottleneck by tristramb on Thursday July 03, 2025 @09:33AM (#44454902)
And for extra credit, create it using an LLM.
Re:Writing Code Was Never the Bottleneck by LunicLynx on Thursday July 03, 2025 @09:25AM (#44454809)
Did anyone say react in the windows start menu?

Folks, we already have bad software. Everywhere.

And nobody cares.

Re:Writing Code Was Never the Bottleneck by kevindamm on Thursday July 03, 2025 @11:19AM (#44455957)
People care, it's just that they're not the ones shipping as often.
Re:Writing Code Was Never the Bottleneck by Sammi on Thursday July 03, 2025 @02:00PM (#44457629)
Windows usage share is slowly and surely falling. People care, they're just slow to realise.

https://gs.statcounter.com/os-market-share/desktop/worldwide...

If you want to sell high quality software, then you must be patient. Several decades worth of patient.

Re:Writing Code Was Never the Bottleneck by Aeolun on Thursday July 03, 2025 @09:31AM (#44454867)
Honestly, I expect LLM’s or the combination of algorithms that make them usable (Claude Code), to get better fast enough that we’ll never reach that phase. All the good devs know what the current problem with LLM assisted coding are, and a lot of them are working to mitigate and/or fix those problems.
Re:Writing Code Was Never the Bottleneck by hn_throwaway_99 on Thursday July 03, 2025 @09:43AM (#44455008)
I'm showing my age, but this is almost exactly analogous to the rise of Visual Basic in the late nineties.

The promise then was similar: "non-programmers" could use a drag-and-drop, WYSIWYG editor to build applications. And, IMO, VB was actually a good product. The problem is that it attracted "developers" who were poor/inexperienced, and so VB apps developed a reputation for being incredibly janky and bad quality.

The same thing is basically happening with AI now, except it's not constrained to a single platform, but instead it's infecting the entire software ecosystem.

Re:Writing Code Was Never the Bottleneck by tstrimple on Thursday July 03, 2025 @12:09PM (#44456504)
It's the exact same thing every time a technical bar is lowered and more people can participate in something. From having to manually produce your own film to having film processing readily available on demand to not needing to process film at all and everyone has a camera in their pocket. The number of people taking photos has absolutely exploded. The average quality of photos has to have fallen through the floor. But you've also got a ton of people who couldn't participate previously for one reason or another who go on to do great things with their new found capabilities.
Re:Writing Code Was Never the Bottleneck by hn_throwaway_99 on Thursday July 03, 2025 @12:44PM (#44456911)
Software is a very different beast though because this crappy technical debt lives on, it often grows "tentacles" with poorly defined boundaries, people and companies come to depend on it, and then the mess must eventually be cleaned up.

Take your photos example. Sure, the number of photos taken has exploded, but who cares if there are now reams and reams of crappy vacation photos - it's not like anyone is really forced to look at it.

With AI-generated code, I think it's actually awesome for small, individual projects. And in capable hands, they can be a fantastic productivity enhancer in the enterprise. But my heart bleeds for the poor sap who is going to eventually have to debug and clean up the mountains of AI code being checked in by folks with a few months/years of experience.

Re:Writing Code Was Never the Bottleneck by dizhn on Friday July 04, 2025 @09:27AM (#44464362)
> , people and companies come to depend on it, and then the mess must eventually be cleaned up.

I have found time and again that enough technological advancement will make previously difficult things easy that when it's time to clean up the old stuff, it's not such a huge issue. Especially so if you do not need to keep a history of everything and can start fresh. This probably would not fly in a huge corp but it's fine for small/medium businesses. After all, whole companies disappear and somehow we live on.

Re:Writing Code Was Never the Bottleneck by Henchman21 on Thursday July 03, 2025 @10:03AM (#44455210)
We turned our back on VB. Do we have the collective will to turn our back on AI? If so I suspect it’ll take a catalyzing event for it to begin. My hunch tells me no, no we don’t have the will.
Re:Writing Code Was Never the Bottleneck by antonvs on Thursday July 03, 2025 @12:17PM (#44456594)
> Do we have the collective will to turn our back on AI?

Why do you believe we should "turn our back on AI"? Have you used it enough to realize what a useful tool it can be?

Wouldn't it make more sense to learn to turn our backs on unhelpful uses of AI?

Re:Writing Code Was Never the Bottleneck by AnotherGoodName on Thursday July 03, 2025 @11:29AM (#44456075)
Fwiw I honestly think it was a mistake to turn our back on vb.

Yes there were a lot of crappy barely functioning programs made in it. But they were programs that wouldn’t have existed otherwise. Eg. For small businesses automating things vb was amazing and even if the program was barely functional it was better than nothing.

Re:Writing Code Was Never the Bottleneck by hnaccount_rng on Thursday July 03, 2025 @12:09PM (#44456503)
Came here looking for this comment!

I think we will need to find a way to communicate “this code is the result of serious engineering work and all tradeoffs have been thought about extensively” and “this code has been vibecoded and no one really cares”. Both sides of that spectrum have their place and absolutely will exist. But it’s dangerous to confuse the two

Re:Writing Code Was Never the Bottleneck by wafflemaker on Thursday July 03, 2025 @01:23PM (#44457273)
There's a simple way to communicate it. Just leave in the emoticons added in comments by the LLM.

Wrote it initially as a joke, but maybe it's not that dumb? I already do it on LinkedIn. I'm job hunting and post slop from time to time to game LinkedIn algorithms to get better positioning among other potential candidates. And not to waste anybody's time, I leave in the emotes at beginning of sentences just so people in the know know it's just slop (so as not to waste their time).

Re:Writing Code Was Never the Bottleneck by hnaccount_rng on Thursday July 03, 2025 @03:15PM (#44458291)
Interesting thought. Yeah.. the whole LLM-generated thing might end up being a boon. It is (reasonably) distinctive. At least for now. And rightly or wrongly it triggers defensive reflexes
Re:Writing Code Was Never the Bottleneck by tstrimple on Thursday July 03, 2025 @12:19PM (#44456617)
When the Derecho hit Iowa and large parts of my area were without power for over a week we got to discover just how many of our very large enterprise processes were dependent to some degree on "toy" apps built in "toy" technologies running on PCs under people's desks. Some of it clever but all of it fragile. It's easy to be a strong technical person and scoff at their efforts. Look how easily it failed! But it also ran for years with so few issues it never rose to IT's attention before a major event literally took the entire regional company offices offline. It caused us some pain as we had to relocate PCs to buildings with sufficient backup power. But overall the effort was far smaller than building all of those apps with the "proper" tools and processes in the first place.

Large companies can be a red tape nightmare for getting anything built. The process overload will kill simple non-strategic initiatives. I can understand and appreciate less technical people who grab whatever tool they can to solve their own problems when they run into blockers like that. Even if they don't solve it in the best way possible according to experts in the field. That feels like the hacker spirit to me.

Re:Writing Code Was Never the Bottleneck by lastdong on Friday July 04, 2025 @05:14AM (#44462735)
Please don’t stop at building “toy” prototypes, it’s a great start, but take some time to iterate, rebuild, bring it to production standards, make it resilient and scalable.

You’d be surprised how little effort it is compared to having to deal a massive outage. E.g. You did eventually had to think about backup power.

Re:Writing Code Was Never the Bottleneck by rightbyte on Thursday July 03, 2025 @12:36PM (#44456803)
Drag and drop GUI builders were awesome. Responsive layouts ruined GUI programming for me. It made it too much of a fuss to make anything "professional".
Re:Writing Code Was Never the Bottleneck by aforwardslash on Thursday July 03, 2025 @04:19PM (#44458826)
We didn't turn our back on VB. Microsoft killed it when it became a citizen of the .NET ecosystem; pairing C# concepts, requiring extensive code changes and an IDE that was read-only during debug (yah, you couldn't edit the code while debugging) killed the product.

Greed (wanting an enterprise alternative to Java and C++ builder) killed VB, not the community.

Re:Writing Code Was Never the Bottleneck by thfuran on Thursday July 03, 2025 @09:55AM (#44455136)
>We're going to be swimming in an ocean of bad software

I think we already are. We're about to be drowning in a cesspit. The support for the broken software is going to be replaced by broken LLM agents.

Re:Writing Code Was Never the Bottleneck by p_v_doom on Thursday July 03, 2025 @10:31AM (#44455454)
> Good experienced devs will be able to make better software

I lowkey disagree. I think good experienced devs will be pressured to write worse software or be bottlenecked by having to deal with bad software. Depends on company and culture of course. But consider that you as expereinced dev now have to explain things that go completely over the head of the junior devs, and most likely the manager/PO, so you become the bottleneck, and all pressure will come down on you. You will hear all kinds of stuff like "80% there is enough" and "dont let perfect be the enemy of good" and "youre blocking the team, we have a deadline" and that will become even worse. Unless you're lucky enough to work in a place with actually good engineering culture.

Re:Writing Code Was Never the Bottleneck by hn_throwaway_99 on Thursday July 03, 2025 @12:52PM (#44456987)
I think the recent post about the Cloudflare engineer who built an OAuth implementation, https://news.ycombinator.com/item?id=44159166, shows otherwise (note the Cloudflare engineer, kentonv, comments a bunch in the discussion). The author, who is clearly an expert, said it took him days to complete what would have taken him weeks or months to write manually.

I love that thread because it clearly shows both the benefits and pitfalls of AI codegen. It saved this expert a ton of time, but the AI also created a bunch of "game over" bugs that a more junior engineer probably would have checked in without a second thought.

Re:Writing Code Was Never the Bottleneck by bornfreddy on Thursday July 03, 2025 @02:03PM (#44457656)
There was also a review of that code about a week later [0] which highlights the problems with LLM-generated code.

Even looking strictly at coding, the hard thing about programming is not writing the code. It is understanding the problem and figuring out an elegant and correct solution, and LLM can't replace that process. They can help with ideas though.

[0] https://news.ycombinator.com/item?id=44215667

Re:Writing Code Was Never the Bottleneck by kentonv on Thursday July 03, 2025 @02:48PM (#44458065)
> There was also a review of that code about a week later [0] which highlights the problems with LLM-generated code.

Not really. This "review" was stretching to find things to criticize in the code, and exaggerated the issues he found. I responded to some of it: https://news.ycombinator.com/item?id=44217254

Unfortunately I think a lot of people commenting on this topic come in with a conclusion they want to reach. It's hard to find people who are objectively looking at the evidence and drawing conclusions with an open mind.

Re:Writing Code Was Never the Bottleneck by bornfreddy on Thursday July 03, 2025 @04:46PM (#44459039)
Thank you for answering, I haven't seen your rebuke before. It does seem that any issues, even if there would be any (your arguments about CORS headers sound convincing to me, but I'm not an expert on the subject - I study them every time I need to deal with this) were not a result of using LLM but a conscious decision. So either way, LLM has helped you achieve this result without introducing any bugs that you missed and Mr. Madden found in his review, which sounds impressive.

I won't say that you have converted me, but maybe I'll give LLMs a shot and judge for myself if they can be useful to me. Thanks, and good luck!

Re:Writing Code Was Never the Bottleneck by kentonv on Thursday July 03, 2025 @06:52PM (#44459782)
To be fair, there was a pretty dumb CVE (which had already been found and fixed by the time the project made the rounds on HN):

https://github.com/cloudflare/workers-oauth-provider/securit...

You can certainly make the argument that this demonstrates risks of AI.

But I kind of feel like the same bug could very easily have been made by a human coder too, and this is why we have code reviews and security reviews. This exact bug was actually on my list of things to check for in review, I even feel like I remember checking for it, and yet, evidently, I did not, which is pretty embarrassing for me.

Re:Writing Code Was Never the Bottleneck by hn_throwaway_99 on Thursday July 03, 2025 @05:54PM (#44459484)
Thanks for responding. I read that dude's review, and it kind of pissed me off in an "akshually I am very smart" sort of way.

Like his first argument was that you didn't have a test case covering every single MUST and MUST NOT in the spec?? I would like to introduce him to the real world - but more to the point, there was nothing in his comments that specifically dinged the AI, and it was just a couple pages of unwarranted shade that was mostly opinion with 0 actual examples of "this part is broken".

> Unfortunately I think a lot of people commenting on this topic come in with a conclusion they want to reach. It's hard to find people who are objectively looking at the evidence and drawing conclusions with an open mind.

Couldn't agree more, which is why I really appreciated the fact that you went to the trouble to document all of the prompts and make them publicly available.

Re:Writing Code Was Never the Bottleneck by paulmooreparks on Thursday July 03, 2025 @08:50PM (#44460314)
You touch on exactly the point that I try to make to the AI-will-replace-XXX-profession crowd: You have to already be an expert in XXX to get the most out of AI. Cf. Gell-Mann Amnesia.
Re:Writing Code Was Never the Bottleneck by imiric on Thursday July 03, 2025 @11:14AM (#44455884)
> I'm expecting to see so much more poor quality software being made. We're going to be swimming in an ocean of bad software.

That's my expectation as well.

The logical outcome of this is that the general public will eventually get fed up, and there will be an industry-wide crash, just like in 1983 and 2000. I suppose this is a requirement for any overly hyped technology to reach the Plateau of Productivity.

Re:Writing Code Was Never the Bottleneck by lelanthran on Thursday July 03, 2025 @02:40PM (#44457995)
> Good experienced devs will be able to make better software,

No, they won't. It's a race to the bottom.

I can take extra time to produce something that won't fall over on the first feature addition, that won't need to be rewritten with a new approach when the models get upgraded/changed/whatever and will reliably work for years with careful addition of new code.

I will get underbid by a viber who produced a turd in an afternoon, and has already spent the money from the project before the end of the week.

Re:Writing Code Was Never the Bottleneck by steveBK123 on Thursday July 03, 2025 @07:27AM (#44453890)
I dealt with a 4x as expensive statement-of-work fixed price contract that was nearshored and then subbed out to a revolving cast of characters.

The SOW was so poorly specified that it was easy to maliciously comply with it, and it had no real acceptance tests. As a result legal didn't think IT would have a leg to stand on arguing with the vendor on the contract, and we ended up constantly re-negotiating on cost for them to make fixes just to get a codebase that never went live.

An example of how bad it was - imagine you have a database of metadata to generate downloader tasks in a tool like airflow, but instead of doing any sane groupings of say the 100 sources with 1000 files each every day into a 100ish tasks, it generated a 700,000 task graph because its gone task-per-file-per-day.

We were using some sort of SaaS dag/scheduler tool at the time and if we deployed we'd have been using 5x more tasks than the entire decades-old, 200 person person were using to date, and paid for it.

Or they implemented the file arrival SLA checker such that it only alerted when a late file arrived. So if a file never arrives it never alerts. Or when a daily file arrives a week late, you get the alert on arrival, not a week ago when it was late.

Re:Writing Code Was Never the Bottleneck by sokoloff on Thursday July 03, 2025 @07:52AM (#44454066)
I have seen the revolving cast of characters bit play out several times. It’s as if they hire 1 or 2 competent people and rotate them to face the client that is currently screaming the loudest.

To be fair though, in your case it aounds like 51% (and maybe even 75+%) of the defect was in the specifications.

Re:Writing Code Was Never the Bottleneck by steveBK123 on Thursday July 03, 2025 @10:31AM (#44455448)
Oh yeah, 75-90% of the outcome was determined by the bad specification/contract.

You can have a loose spec and trust the team to do the right thing if it's an internal team you will allocate budget/time to iterate. Not if you have a fixed time & cost contract.

Re:Writing Code Was Never the Bottleneck by gopher_space on Thursday July 03, 2025 @01:35PM (#44457387)
We found that any competent offshore contact would leave for a better job within a month.
Re:Writing Code Was Never the Bottleneck by ortusdux on Thursday July 03, 2025 @12:29PM (#44456717)
Nailing the SOWs and acceptance test requirements is key. They can mean the difference between toxic dog food or mail trucks that last decades.

https://en.wikipedia.org/wiki/2007_pet_food_recalls

https://en.wikipedia.org/wiki/Grumman_LLV

Re:Writing Code Was Never the Bottleneck by samat on Thursday July 03, 2025 @01:26PM (#44457308)
We do quality outsource development for usual web/mobile stuff (yeah, it exists).

80% of our job is helping clients to figure out what do they actually need and what's reasonable to implement given current state of tech, finding that balance between ideal and realistic software, or rather negotiating it.

So expecting client to write SOWs/specifications is like expecting client to write code.

Aha, actually, I've recently seen it quite few times: people send me detailed SOW which look good, but once I try to read them to actually create an understanding of the domain logic/program in my head — it does not make any sense.

Very close to the grand-grand-parent comment about mentoring junior programmers. Now imagine they are the one paying you!

Re:Writing Code Was Never the Bottleneck by steveBK123 on Thursday July 03, 2025 @03:27PM (#44458388)
I’d argue with software that the level of detail you need to specify to do a successful SOW is so much work you’d might as well then just do the dev work too.

It also cuts against all trends of iterative development in that it is like waterfall with a gun to your head to get the spec 1000% right.

Re:Writing Code Was Never the Bottleneck by MaxBarraclough on Thursday July 03, 2025 @07:29AM (#44453903)
This sounds like a tale of failed 'waterfall model' software development.

Was it not possible to sees the quality issues before the project was finished?

Re:Writing Code Was Never the Bottleneck by david-gpu on Thursday July 03, 2025 @07:55AM (#44454083)
I once saw something like that where there was an existing codebase and a different business unit in the company wanted to add a large new feature.

The contractors simply wanted to get paid, naturally. The people who paid them didn't understand the original codebase, and they did not communicate with the people who designed and built the original codebase either. The people who built the original code were overworked and saw the whole bruhaha as a burden over which they had no control.

It was a low seven figure contract. The feature was scrapped after two or three years while the original product lived on and evolved for many years after that.

I hope that management learned their lesson, but I doubt it.

Re:Writing Code Was Never the Bottleneck by pjmlp on Thursday July 03, 2025 @07:40AM (#44453980)
As participant in many kinds of similar projects, lets put it this way, the crew already knows that the ship has a few holes while at the harbour, but captain decides for sailing anyway.

Eventually you will find yourself on deep waters, with the ship lower than it should be, routinely taking out buckets of water, whishing for the nearest island, only to repair ship with whatever is on that island, and keep sailing to the nearest one, with the buckets ready.

After a couple of enterprise projects, one learns it is either move into another business, or learn to cope with this approach.

Which might be specially trick given the job landscape on someone's region.

Re:Writing Code Was Never the Bottleneck by fredrikholm on Thursday July 03, 2025 @07:49AM (#44454049)
My suspicion is that all type of work is this; a universal issue where quality and forethought are at odds with quantity and good enough (where good enough trends towards worse over time).

Before SE I had a bunch of vastly different jobs and they all suffered from something akin to crab bucket mentality where doing a good job was something you got away with.

I've had jobs where doing the right thing was something you kept to yourself or suffer for it.

Re:Writing Code Was Never the Bottleneck by pydry on Thursday July 03, 2025 @08:00AM (#44454117)
This almost seems to be a weird artefact of capitalism. Ive worked on several projects which were obviously doomed to almost everybody in the trenches but management and investors kept believing. Perception of reality did not permeate the class divide.

I wish I could make $$$ off this insight somehow but im not sure how.

Re:Writing Code Was Never the Bottleneck by breppp on Thursday July 03, 2025 @08:31AM (#44454331)
Create a revolutionary movement, take over the state and steal the money of the lower classes
Re:Writing Code Was Never the Bottleneck by disgruntledphd2 on Thursday July 03, 2025 @11:21AM (#44455976)
I think this is driven more by hierarchy and power games rather than capitalism. Basically, if your superiors don't want to hear bad news, then either you'll tell them good news only or you'll be replaced by someone who will.

Source: I've been replaced by this process a number of times.

Re:Writing Code Was Never the Bottleneck by adwn on Thursday July 03, 2025 @11:27AM (#44456050)
> This almost seems to be a weird artefact of capitalism.

I don't see how this would be causally linked to capitalism in any meaningful way.

Re:Writing Code Was Never the Bottleneck by lanstin on Sunday July 06, 2025 @12:56PM (#44482271)
Because hundreds of years after multiple things have proven that systems with free and open flow of information, skills, and techniques beats any system where information is walled off, capitalism (or corporatism really) still insists, all too often, on favoring feudal style top down methods of control instead of bottom up “empower the teams and facilitate the flow of information”; they don’t merely suppress the flow of information they actively ignore information; and they prefer people idle rather than work on non-approved priorities.

Many people use capitalism to mean the system of multinational corps and their secretive, hierarchical, and morally offensive ways, rather than anything to do with free market economics (which are predicated on the free flow of information in the market).

Re:Writing Code Was Never the Bottleneck by pjc50 on Thursday July 03, 2025 @08:38AM (#44454395)
The trick with waterfall is that discovering issues is deferred until the very last phases of test and user acceptance, at which point it's too late to do anything.
Re:Writing Code Was Never the Bottleneck by AbstractH24 on Thursday July 03, 2025 @06:36AM (#44453595)
Cheap labor with low EI is/has been what will suffer most from generative AI.
Re:Writing Code Was Never the Bottleneck by vages on Thursday July 03, 2025 @07:10AM (#44453804)
What does EI mean in this sentence? Tried looking it up and found no definition that stood out.
Re:Writing Code Was Never the Bottleneck by steveBK123 on Thursday July 03, 2025 @07:14AM (#44453833)
Emotional intelligence
Re:Writing Code Was Never the Bottleneck by viraptor on Thursday July 03, 2025 @10:05AM (#44455223)
> They did not spend one second beyond the spec sheet and none of the common sense things that "follow" from the spec were there.

That's how lots of the early outsourced projects ended up. Perfectly matching the spec and not working.

> The whole thing was scrapped immediately.

And that's how it ended up too. everything old is new again.

Re:Writing Code Was Never the Bottleneck by euroderf on Sunday July 06, 2025 @08:37AM (#44480252)
> With LLMs this kind of work now basically becomes free to do and automatic.

So is this going to kill the demand for offshored code ? If you can get the same needs-babysitting code quality in no-time and no-budget ?