Arbitrage. Devs know its gamed. VCs less so.

You can argue that abstractions hide consequences that fall on users who didn't choose them, but I'd argue back that LLMs likely have a better understanding of a11y conventions than I do as well.

The end result is more crunch and a sharp decline in software quality, maybe even job satisfaction in general. As an (unfortunately anecdotal) example, I started to find myself fixing up broken websites or removing elements that get in the way with dev tools and uBlock every once in a while, and have heard from other people on here that they have been doing the same (https://news.ycombinator.com/item?id=47042747). All to restore basic functionality of websites I go on. This was never required back in the day, Flash and early web browsers didn't even have the option to do this.

Another, less anecdotal example from a while ago: https://news.ycombinator.com/item?id=47390945

It gets worse when you realize that most of the money saved through these cuts only benefits the very top of the hierarchy.

Compared to the status quo where people pretty much never consider these things, like accessibility, especially not for an MVP? How many people have never added written aria attribute? I would suspect 90%+ of people touching the frontend.

The difference with LLMs is that (1) they have a latent rigor for things that you weren't going to spend time caring about anyways and, more importantly, (2) you can encode these things into prompts (AGENTS.md) and processes so that they happen even when you weren't going to invest the time with or without AI. For a lot of people this only means collecting some generic "skills" they found online yet it's still much better than what they were going to do pre-AI.

That's why I think AI is saving software in some ways, not leading to worse software.

Or, asserting that AI will botch software might hold more weight with people who have already forgotten how dogshit software was pre-AI.

If our hypothetical developer hasn't used any accessibility-related tags before, what chance is there that those parts of the website will receive adequate testing?

Testing is so hard that we'll agree that, e.g., TDD is great (e.g. ensure your tests actually test something, ensure your code is testable from the start) yet we never do it. And when we do write tests, we are on the hook to be eternally vigilant that they are not stale, that they test something real, that they are not redundant. And they often turn into an append-only file that you resent.

Meanwhile, AI is happy to write tests, do red-green TDD cycles, refactor them, prune them, update them, justify and defend them. It will even incidentally write tests for the most aloof vibe-coder by accident because they didn't specify otherwise.

Overnight, I went from never testing most of my side projects (except for, say, maybe unit tests in more straightforward things like a parser) to now everything is tested end-to-end. Every time I make a new directional / architectural decision, the tests the AI writes also encode it at the test level to reenforce the decision.

It's strictly a better world for software because AI can write and maintain tests.

> LLM-assisted codebases, at least these days, only stick together thanks to testing

But tests also help humans and ensure human-written software is robust. We only don't test because they are so costly to write and maintain, and our software has always suffered for it. Or the tests become such an unmaintainable mess that our software is now worse because of it!

- good test, wrong layer, would turn into a mess of "wait why'd tests over there blow up for changes over here"

- mostly-good test, subtle issue (yes, this is the status quo with most human-written tests, but the risk of not being careful is that you (or the agent you throw at crap) now is overconfident in your future changes)

- weird silly test like "assert that calling the six statements in this method in the right order do the right thing" without... actually calling the method itself... so don't protect against changes to the method?

For non-greenfield work I've recently been much more happy with their out of the box code change quality then their attempts at adding coverage for those changes!

I think this is an area that has remained hard because putting directives in CLAUDE.md or whatnot for tests is generally gonna be so generic to be useless, like "put tests in the right place" without more module-specific context. Whereas if I'm making a non-greenfield change, I'm thinking much more in my prompt about constraints on the code itself, and much less about the current shape/state/organization of the tests or what to direct it on.

Properly used it's great. Definitely improved my test coverage a lot.

But it's entirely still in the world of "people who'd care to write good code before will write good code faster; other people will just write mediocre code faster."

I read some AI generated tests and while it looks visually impressive, ultimately it wasn’t doing anything valuable? Why? because of all the mocks and scenarios that didn’t matter. And on top of that, tests are additional code to maintain.

These days, I don’t even bother with unit testing. They are a maintenance burden. I focus on integration test (whole modules) and if I have the time, on a harness to do e2e testing.

I agree integration tests are best, with some e2e testing for common scenarios.

I worked at a place that required unit tests for every new method or function. Arguments like "this other (integration) test already covers that. why do I have to add another test?" wouldn't fly. PR reviews would often degrade into arguments about testing and how all database access needed to be mocked...

I just saw this comment yesterday about one of the tests from Bun’s rust rewrite: https://news.ycombinator.com/item?id=48314311 It reads in the raw source code and uses a regex to assert that “unsafe” is used.

> These days, I don’t even bother with unit testing. They are a maintenance burden

I’ve come to the same conclusion, but that’s only because I’m working on solo projects. I think they are probably worth it with multiple devs on the same project.

But that was my testing strategy already, but writing one of those tests could take legitimately hours with how many columns and crazy rules our area has.

You're responding to an assertion with an assertion. It has been empirically proven that SOTA models can create more dogshit software than pre-AI software. It is also trivially known that the user is unable to predict when and how the AI will introduce dogshit into the software. We literally had a study posted on this forum claiming models give more accurate answers if you're mean to them. This is the shit we're dealing with. Stuff you couldn't make up in a dystopian Douglas Adams novel.

>you can encode these things into prompts

Is this satire? SOTA models randomly disobey rules in prompts all the time.

When a dev drops a production db I can warn them. If they do it multiple times during their employment I can change their roles or fire them.

I can count the number of companies providing SOTA models with the fingers on my hands. Imagine having an employee pool of only 5 savant coders with dementia to choose from to hire to your company. That's it. Thats the entire applicant pool. You can only fire one of them by hiring one of the other four to replace them with. And you can't really fire them for dropping production dbs if you can't prevent the other ones from making the same mistake. This is the current AI-first hellscape as it stands.

But the key here is: LLMs don't have latent rigor, nor any other kind of rigor.

The status quo with pre-AI Human Written software on a pedestal is that it doesn't work, and it lacks accessibility, polish, performance considerations, UX considerations, tests, and more.

The built-in rigor is trivial to prove. Just put Opus 4.8 in plan mode and tell it to plan something, like a vt100 emulator.

The question isn't whether you can do better than AI, because you'll put your foot on the scale and give yourself infinite time, attention, and energy just so you can say yes. It's whether AI can do as good or better than you with the same time, attention, and energy you would have given a task in the first place.

For example, imagine if textual-serve author would reimplement xterm.js What effect it would make on quality.

LLMs increase technical debt rapidly. It is unclear whether they can deal with the mess they create. But we'll know soon (no need to wait years, to get immovable mess).

The positive side of LLMs is that they confirm experimentally the usefulness of many software engineering practices (testing,docs, adrs, design, formal specs etc)

Could I have done it on my own? Yes, eventually. The problem is I would've lost interest and moved on to some other useless project before getting that far.

It depends on the software. But, generally speaking, I try to use and write the best software available that solves my problem, even if it's one of a kind; it doesn't really matter if the other 99.9999% of the software in the space is broken.

Given 1000 hours to work on a problem, an LLM will continue to yeet out mediocre variations on a theme. Give me 1000 hours to work, and my product will keep getting 1% or 2% better until it's much better than any shit an LLM would spit out.

Similarly, I would much rather use someone else's emulator that they spent 1000 hours on than have AI yeet out some mediocre shit that kinda works, but is really just a mindless exploitation of something that someone else wrote that was actually good.

Then, you follow that with, "Yeah, but AI just allows you to iterate faster and skip the boring stuff, so that you make your product better even faster."

And then I follow that with, "The part where you take it apart piece by piece and study each piece and get kicked in the head by the realities of your lack of understanding is the part that's actually valuable, and it's precisely what you're skipping with an LLM"

You get a lot of things for free with LLMs. You program an input box that goes to a form, handle the backend, make sure the variable names match the box, the API, the data structures and the database columns. All the brain matter making sure that flow works is mastered by an LLM since even with GPT 3.5 (not that I am advocating using that anymore). But the point is, since that's taken care of, why not also let it handle aria, input hints, mouse effects, state storage, animations since most of it's handled by putting "handle aria, input hints, mouse effects, state storage, animations" any time the front end files are changed." in agents.md

I would say that's rigor. Now you go a step further and have another LLM in your QA cycle that double checks it.

Setting that up and making sure it works, at the early stages, is not what LLMs do best, today. This sort of work is possibly incredibly valuable in the next 12-36 months, depending on what LLMs can be designed to do out of the box.

An Agent that can deliver the correct legal review process for a patent and is correct often enough to validate the savings vs real humans, or at least the speed increase + manual review ala code reviews, is incredibly valuable.

Are we there yet? Maybe this is where current groups like FNCR are trying to go.

So far the way AI is making software better is mostly checking for common bugs and acting as review/pair programming buddy, not the code.

The code is bad. At best okay. But you can make a lot of it. And it's not bad enough to not be good enough.

Today I find myself having less patience for it all, because things just tend to work a lot more often than they don't.

With AI, I find so many small businesses and others I deal with which have their own websites have started to have better design, better performance and while I don't know if they are really accessible but they tend to have more prevalence of aria labels.

Not to take away from your experiences, just sharing my anecdotes.

For example, WPF programs can have great accessibility - this comes from the fact that programmers can manipulate primitives which are semantically meaningful (buttons, lists etc).

In HTML its just a sea of divs which lately have become an implementation detail to hang classes on to, and sometimes not even exposed directly to the developer, if you use a SPA framework.

There's not a snowballs chance in hell you can build a quality accesibility solution on top of that.

HTML's main idea was that HTML was a document model, that described the content in a semantically meaningful way, and CSS was the 'rest' which kind of allowed to make the whole thing pretty - the idea going as far as separating content from looks should allow people to 'theme' their websites and completely redefine layout.

That idea has been completely abadoned. I'm not a frontend dev - although I can make a competent webpage by myself, I don't have deep insights into what's going on in the field - maybe Web Components will allow people to create semantically meaningful pages in a standard way?

Maybe there should be another layer of abstraction on top of what we have - which is truly semantic, this time for real?

AI might make the problem worse, it might not. But the problems you outline and the sharply declining computer literacy they bring are already here, driven 100% by human developers.

Contrary to what you seem to believe, cars and bicycles are different kinds of things, not two versions of the same fundamental type, so this rhetorical question doesn't make much sense (consider that also your legs provide the function of transportation but are nevertheless not a kind of car).

Only when you have a PR problem does the business switch back to signalling quality, like Microsoft, although it remains to be seen if they still have the quality part. Most of the craftspeople get to say 'told you so' but also it looks like a sinking ship to them. Once the PR problem is gone, it's back to shipping at the expense of quality.

This cycle conflicts with the idea of a craft, which is that you should do it that way all/most of the time. The business will stop caring about quality long enough that your skills will erode, making it a bad mix. Trying to practice a craft where you aren't in control of this cycle is corrosive to the spirit.

No, other people did. They wrote about it, and LLM can sometimes use that. Once they no longer write about it, what then?

> More people building things is straightforwardly good, and if some of those things are slower or less accessible, that's a tradeoff people are entitled to make.

That I agree with. The more the merrier, all else being the same. And if "AI" trickled into everything because of the undeniable improvements it leads to, the situation and most of the sentiments would be very different, I think.

But even then, people aren't entitled to the knowledge "created" by doing the work. If attribution and compensation were tackled in earnest, if you could only train on the materials of the people you pay to produce those materials, it might be much quicker and cheaper to just learn CSS.

It can read the code? Historical discussions around it? Commit histories?

> But even then, people aren't entitled to the knowledge "created" by doing the work. If attribution and compensation were tackled in earnest, if you could only train on the materials of the people you pay to produce those materials, it might be much quicker and cheaper to just learn CSS.

OSS code and people’s public writings are available to anyone all the time. Common Crawl, the open source web crawl dump, has been around for over a decade. No one had any problem with these systems being developed on them, until they finally started to become useful, so what’s the sort of legal or ethical framework you’re pointing to?

Assume everybody is now using LLM because they're better, and because the people who created artisanal things in their free time out of sheer generosity no longer have free time, or any food at all, or simply no longer feel generous. And the few people who are such specialists that they would be slowed down by them only do proprietary work, for lots of money.

What then? LLM learning from LLM doesn't really work, does it?

This is not intended as some kind of gotcha, to me this is a huge elephant on the couch.

> No one had any problem with these systems being developed on them, until they finally started to become useful, so what’s the sort of legal or ethical framework you’re pointing to?

That it's perfectly fine for people to say "I was fine with that, but I'm not fine with this". They can give you detailed explanations for their individual decisions, every single one of them, but there is no point in discussing them in aggregate because that aggregate is an abstraction. And they're optional, too, it's not like people have to give an explanation, and aren't simply free to change their mind for no or for bad reasons.

My documentation tends to be more thorough and well-maintained when I'm building software with a coding agent. A million tokens of context tends to be better at that kind of thing than my own brain when I'm neck-deep in solving a difficult problem.

And presuming the best practices are adequate and don't need to evolve (which seems unlikely) - then the current public historical record is also adequate.

> What then? LLM learning from LLM doesn't really work, does it?

Oh what no that’s exactly how it works, even today. RL with verification is done with synthetic data and rejection sampling. If something can’t get done purely with an agent that needs to get done it’s done with human help, this will always be the case it will just get rare-er.

> That it's perfectly fine for people to say "I was fine with that, but I'm not fine with this".

Agree with you there, but there’s a theme or insinuation (not saying you’re saying this) that these companies “stole work” (which definitely a lot of copyright violations sure), but it’s just unclear to me what principles or legal frameworks these companies or institutions should have used to develop the technology. I don’t really even know whether I mean to imply it’s not unethical, moreso I’m looking for a steel man argument to this. But of course people are entitled to their value systems and judgements and to point out real harm.

Oh, I'm absolutely one of the people saying that a lot of companies stole a lot of work, and that it would be better to dissolve them and make all their assets public domain, than to stand for it.

The legal and moral framework is to ask for permission, accept "no". The same framework they use against you in an instant, with an army of lawyers, when you do to them what they did to everybody.

None of this in principle, technically, requires slurping up everything and ignoring consent, that just made it quicker and cheaper, that's why they did it. While they did that, I'm sure other labs made progress in the same direction at much smaller pace, in a defensible manner, of which they should get to keep the fruit.

It does work, it is called RLVR, reinforcement learning from verified rewards, is is based on testing code by execution. It's become a major area of improvement in the last year. But you are also forgetting the amount of steering and problem solving going into coding agents today, and the huge logs they create which can feedback into training. We automated stackoverflow, LLM learns from usage and self play.

theyve already been added to all the big labs' datasets, its not like its going anywhere.

but even moreso, accessibility tools exist because people need them, and will make it known when the accessibility is broken.

the screen reader is still gonna expose an api or have observable outputs.

There's very real forcing functions that will keep making useful content about what people want and need from accessibility tools, and how to interact with existing tools.

you're still building for people and the harness operator as time goes on, will probably be the actual user, and will push the LLM to adjust the code to be great for them

And if everyone bunkers up and all that open content dries up starting in 2026, let's say, what happens?

Many kinds of technology faced this kind of tragedy of the commons argument in the past and it never bears out. Printing presses copied manuscripts, search engines copied and indexed web pages, open-source software was incorporated into commercial products, Wikipedia repackaged knowledge produced elsewhere.

In almost all cases the total amount of creation increases because the technology lowered costs, expanded audiences, or created new forms of value. The speed of creation of new 'View Source' outpaces the number of people pulling back.

A lot of open-source software was supported by developers having stable well-paying jobs that didn't burn them out and afforded them enough free time to work on passion projects on the side, so that even if their company wasn't directly supporting their OSS development, there was still an indirect link.

Not only is this likely to increasingly change in the future as people need to spend more time navigating the disruption AI will have on labor, it already visibly has been changing over the past year.

One of the top posts on HN today is someone leaving open source and tech completely to work at Home Depot -- while this is an extreme case it isn't wholly unique to what I'm seeing in many places since 2025.

That is not the dynamic with LLM. You see LLM output, but original creator is hidden. And if you write your own, no one will find it. Worst, other people will tell you "LLM could have write it" in reaction ... so people wont bother.

> search engines copied and indexed web pages

Notably, search engines sent people toward web pages. And when search engines stopped doing that and started to copy content, those original pages started to die out.

> Printing presses copied manuscripts

Printing press made dissemination easier. It is an equivalent of early internet, not of LLM.

> open-source software was incorporated into commercial products

Commercial product using open source library had different user then the library it is using. And crucially, it is not hiding that library from the library user.

> Wikipedia repackaged knowledge produced elsewhere

Yes, and we collectively create less encyclopedias. They are not worth writing and checking for correctness anymore, so we don't do that all that much anymore.

Imagine you have a 4B model and keep an equal size corpus of search stubs, small MD documents linking to hubs, feeds and search engines for millions of topics. You can use the LLM to read the stub and perform the search for you, all orchestrated locally, with greater privacy and independence. You can dis-intermediate the search chokepoint now. You can set the criteria for what to include, exclude, how to rank and present the results.

This works because good entry points for any topic change slowly over time. The construction of search stubs is trivial with existing AI agents, and can be shared as open source. A few GB for the model, a few for the search routing layer, and you got a sovereign local agent.

If this holds, access control shifts from whatever Google thinks maximizes profit to whatever the community thinks has value.

But most crutially, what you described is not an actual thing people do.

But this doesn't lower the cost of learning and writing CSS, it just scoops up some of it and offers that cheaply, and even that only because it's offered below cost. If anything I'd say it increases the cost, because now you don't get paid to get and be good at what an LLM is supposedly good enough at, and have less free time to do it anyway. You may not even have a computer because your current one broke and you can't afford a new one.

It seems like a lot of the underlying sentiment which was driving that was to contribute to the world and make things better for our fellow people.

Working on OSS software sure doesn't feel as rewarding in the last few years, so I've personally stepped back from 99% of what I do. As have more public people that have worked on OSS for a long time.

Do you think creating the orders of magnitude of content the internet produced organically and which LLM creators are stealing is cheap? If they actually have to pay for content creation while competing with content creators on the you know, content creation front via LLM-generation, the entire business model of LLMs collapses.

You can't have the mountains of data needed for LLMs in the decades to come, if your LLMs put the writers and artists out of work.

We will see how this shakes out in the coming years, as Anthropic, OpenAI & co file for IPO or run out of private funding. Grok is already on the ropes as seen from the SpaceX IPO.

And yes, we will see how it shakes out, Anthropic or OpenAI may collapse just as netscape did, but I hope your implication is not "AI in general will be extinguished like the blockchain" or something

Nothing was set in stone. The way many historical things happened the way they did was due to accident, sheer chance.

> And yes, we will see how it shakes out, Anthropic or OpenAI may collapse just as netscape did, but I hope your implication is not "AI in general will be extinguished like the blockchain" or something

I think the current LLM economy will collapse, leaving behind a few survivors. There will be widespread adoption of cheap OSS LLMs and of more limited, economically viable functionality provided by people with deep pockets like Google. As LLM economics start making more sense, LLMs will be everywhere, once the hardware becomes cheaper and more available.

Regarding lawsuits, do you think Disney & co will take this lying down? The freaking DMCA - an American law - is enforced <<internationally>>. It will take a long time but LLMs will be domesticated.

I agree with you on a technical level and even in a non-cynical "humanity really can rally and change things that seem insurmountable" but you have read way more history than I have. All I know is you have such a frantic geopolitical aspect to this, and such a staggering amount of funding and addressable market, which means unlike blockchain this is both powered by business _and_ government (no government would give up control of the money supply, shocking to me that people believe this), that I see zero path to winding anything down.

> I think the current LLM economy will collapse, leaving behind a few survivors. There will be widespread adoption of cheap OSS LLMs and of more limited, economically viable functionality provided by people with deep pockets like Google. As LLM economics start making more sense, LLMs will be everywhere, once the hardware becomes cheaper and more available.

Cheap OSS LLMs are used everywhere, all the time. They are great, and with subsidies from say China, they could even be competitive with frontier models, but that model of the world requires this mysterious OSS development running at a big big loss. It takes almost a billion dollars to train a frontier model. For many many cases, you do not need frontier model performance. When I do say video captioning, I use small OSS VL models.

Is your theory predicated on OSS models filling some sort of performance gap between the frontier? Or a compromise for less spend at a lower performance? What to you doesn't make sense about LLM economics? Like, LLM's are everywhere. If you think "oh people will just settle for slightly less performance for cheaper" that should have already played out, we've had the same dynamics at every scale: frontier performance is expensive, but then that same performance will cost roughly 10x less in 1 years time. But you don't see people stopping at like GPT-4 and not adopting the frontier models of today.

I think you're right about the value of OSS LLMs but I don't see what would change the calculus to make frontier models somehow less important. It's like in the 90's when we were like "1 GIGABYTE OF RAM? how will that ever be necessary!?!?" and sure, you don't need 1 GB of ram for everything! We have embedded systems. But it's not like there isn't a booming market for >> 1 GB memory modules.

> Regarding lawsuits, do you think Disney & co will take this lying down? The freaking DMCA - an American law - is enforced <<internationally>>. It will take a long time but LLMs will be domesticated.

Not saying lawsuits will be fruitless, I'm sure they will chip something off of the industry, but by now it just won't matter. We're talking about trillions in spend, multiple countries, a government that sees this as a non-negotiable game to win from a geopolitical and military standpoint, and our government knows that they can't execute this themselves despite what I imagine is their distaste for Silicon Valley tech CEOs and their grandstanding. Maybe a lawsuit kneecaps someone, which would be huge, but that doesn't matter for AI generally. Maybe a lawsuit restricts data use, that's fine, these companies have deep pockets for licensing and commissioning datasets; they have opt-in-by-default user flywheels.

We're not such a smart species. It's not like we managed so far. We're just adding unsolved problems, and distract ourselves with even bigger problems. The world could have been fed and clothed by the mid 20th century and we could have solved climate change by the 1980s (talking out of my ass here but with confidence in my general point with that), but instead we now throw everything into the furnace. in the hopes it will create a deus ex machina, like in that very bad Isaac Asimov story. I think we are absolutely capable of lobotomizing ourselves (as a species) like a toddler playing with an electrical socket shocking itself. I don't say this to be snarky, I honestly think we're that unserious and ignorant about what we do and the environment we do it in.

But I also really should look into what you answered about LLM learning from themselves, I heard it mentioned before but I still have no real clue. I will try to rectify that. I mean, I really, really want to be wrong on this, only a monster wouldn't.

I dont think it will be "too late" by any reasonable definition. All those things are learnable and companies that will really need to overcome it, will. But, they wont be open with their knowledge. Learning/training will be expensive and once people acquire it, they wont share it like open sources and programming tech blogs did.

I wrote a similar HN comment around this yesterday, but the short version is that we found for our product that the years of investment in our Docs (which were seemingly never good enough) are now paying enormous dividends in that LLMs seem to understand our product really well. This has manifested in the LLM in our product being highly effective and a few additional clients who found us through AI chats. Turns out the problem with our Docs wasn't so much with their content, but rather that people just weren't looking at them much.

That’s a good question but I suspect when new technologies come out, the normally indecipherable specs released by industry groups (which is why we needed blogs) will be deciphered by LLMs. Not saying this is good or bad (it’s likely both) just saying it.

The AI will no longer be able to reproduce new a11y conventions/guidelines, but if no one is writing about it, do any new a11y conventions/guidelines even exist at that point?

This one, for instance:

> But exactly which details are deemed “unimportant” is a very consequential and sometimes subjective decision. And eventually, the details always leak through.

Right, so you're saying this new technology will still reward deep technical understanding, because there's no way around it. I agree. Why is the whole tone of this thing "AI is making my craft a cheap commodity?"

Websites are largely better, technically, than they were 10 years ago. They're more full-featured, they're faster, SSL/a11y/responsiveness are stronger defaults. Content mills / SEO / news sites are a separate, terrible failure mode of ads and corporate incentives. That's not React's fault!

This seems like a good insight and it feels true to me as well.

My guess is the absolute number of people who treat it like a "craft" is higher than 20 years ago, but as a fraction of all developers it has shrunk dramatically.

This is the opposite of my experience. I find websites take much more time to load, are designed to require many more actions and interaction time to navigate, often break and are replaced by a blank page if any error occurs, use huge numbers of ad/tracking requests and JS, and are filled with accessibility-standard-violating unnecessary JS animations.

That is not remotely the case. All software, not just websites, is a lot worse than it was 10 years ago. Bloated, slow, buggy messes that resulted from the industry hiring a bunch of people who just wanted to do the bare minimum and make fat stacks, rather than hiring people who actually care about good engineering.

Holy shit, no, they are not. What world do you live in?

And I'm sure I'm not alone in feeling that the convenience from ignoring the "deep expertise" and piling on hacks and lazy abstractions, all the way to modern multi-MB frameworks and Electron, is a regression.

Of course no one gives a shit about things like the user's computer/memory utilization. Or degraded experience. Or wasted bandwidth. Or the extra energy costs per 8 billion people - and the environmental impact.

>More people building things is straightforwardly good,

Is more people building public infrastructure "straightforwardly good"? If it means worse roads, worse bridges, systems that fail?

The same holds for software. And most things really.

But again, accidental complexity. The web platform is utterly rotten. So the people we should blame are chrome et al for not providing a standard lib or anything approaching a reasonable UI framework, which forces people to reimplement what a competent platform provides.

Electron is an artifact of the richest companies in the world prioritizing their platform monopolies and trying to increase their stranglehold on businesses by forcing them to write platform specific code, which is hysterically expensive to build and maintain. When I'm confronted with writing for web then reimplementing for mac and win... the answer is electron. I don't think anybody likes building in Electron; it's just it's that or +200% (or more) eng headcount to build 3 apps, one per platform.

And yet we could build native apps a plenty in the 90s and 2000s, with 1/100 the resources (tutorials, third party libs, native GUI frameworks, IDEs, etc) available, and 1/10th the target user base.

It's not about "platform specific code, being hysterically expensive to build and maintain". It was more expensive in the 1990s and 00s too, but people built it and maintained it just fine.

It's companies chosing convenience.

Especially since it's not poor programmers and small software shops going for Electron. It's the biggest multi-billion to trillion dollar companies.

Facebook uses this crap, Slack uses this crap, Adobe and Google use similar web-based UI crap (in what used to be native apps), and so on.

And 1/100th the feature footprint.

Is it? I know hating CSS is a fun pastime for folks around here, but maybe it’s just that building good, rich user interfaces that people can use is an inherently hard problem.

Sure, the browser is slightly more difficult due to maintaining backwards compatibility and multiple implementations, but I’ve yet to see a better UI framework/language that has to deal with the other constraints of the web platform.

That CSS and web never really addressed did they? There's almost nothing in the web platform to build rich user interfaces. You can barely do styled text.

CSS and HTML are literally littered with accidental, ad-hoc, badly thought-out and badly designed one-off solutions, often to problems no one asked for. There's a reason it took until 2026 to animate `height: auto`. There's a reason why `article` "semantic" element has to be used when you display product cards or widgets. There's a reason why CSS scoping has been stuck in limbo for 10+ years. There's a reason...

The web is one of humanity's greatest achievements. But let's not pretend that it's not a textbook study in accidental complexity.

Let me guess, you stopped reading web standards documents because Facebook told you it didn’t matter, since you could just ship 10MB of javascript with every request

Try again.

Well there's your problem right there

But then CSS came along and threw out the baby with the bathwater, returning us back to the bare primitives, forcing entities to redo all that work again. Except this time CSS didn't offer a good mechanism to wrap up that hard work in a nice API bow, so everyone ended up getting pushed into having to redo that same hard work every time they started a new project, leading to a bunch of poor, inconsistent, and often downright wacky implementations.

To be fair, the problem isn't CSS per se, it is just that it is much too low-level for all but the small number of entities focused on the aforementioned hard problems and browsers failed to offer anything higher-level for the rest of us. Javascript has tried taking on a stand-in role for the lack of the higher-level abstraction being natively offered by the browser, but that comes with its own limitations so it isn't always a viable choice, not to mention that having to resort to using a full programming environment completely defeats the purpose of having CSS.

CSS gets all the hate because it is more often than not the wrong tool for the job but the only tool available at hand.

Javascript is used for the Gnome shell and it’s doing a fine job there. And if you paired javascript to something like Tk (as in Tcl/Tk), I guess it would be fine too. The web primitives are just horrible for desktop uses.

That's what PDF is for. CSS is for documents, but namely documents for screens, and on screens you want consistency with all the things on that same screen.

> there’s a load of templates (and frameworks) on the internet if you want a standard set of components.

But not a great way to use them. You can make anything work when you have low-level primitives, so it is not a case that it cannot be done, but that's missing the forest for the trees. You can also program a computer by flipping toggle switches, yet we developed better tools (e.g. programming languages) because sometimes its nice to have more comfortable abstractions.

I dunno, seemed easier 20+ years ago when in high school we were taught how to use Delphi than now.

HTML/CSS is just terrible way to build interfaces. It was made to build basically resizeable documents, not applications, and it shows in every crevice

At first it confused me why my GPU usage spiked and fans started blowing harder, but now I see it is a common mistake that AI makes but no one tests properly. It is possible a human can make this mistake but I sheldom experienced this ever in my life until now.

I run 240hz monitors, and that meant the browser was trying to do 240 repaints per second. Blocking it with unlock origin is the only way. Ridiculous

I think the original author has a much stronger thesis around AI devaluing the craft of coding, but his specific examples don't stack up.

If the goal is a legitimate app that has the lifecycle of an app that you start up and then shut down today the answer is "just write a web application" and then it "just works" on Windows, MacOS, Linux, iOS, Android, Meta Quest, etc.

Mostly people get pissed about Electron because they have 15 Electron apps running in the tray burning up resources all the time and popping up stuff that covers the tray and other tray applications in those (very rare) cases that you want to interact with something in the tray.

It's a tray problem, not an Electron problem. That is, people use Electron specifically because they want to made rude applications which march all over your desktop in muddy boots: Electron is not a framework for writing well-behaved, polite, x-platform applications; you don't need that, you have the web! Electron is a framework for making rude applications that inhabit your tray, pop-up distracting notifications, etc.

The resource burn is an Electron problem. I member using HTML as "Active Desktop" in the Windows 98 era. You could drag an Internet Explorer widget into VB6 applications if you wanted (OLE, COM and ActiveX, damn that was an era of powerful technologies!). But it was one shared runtime across the OS which meant it did not have anywhere near close to the performance impact that even one Electron app has today.

Edit: There's not just one lost decade of the web. There's the browser wars and IE stagnant dominance. There's the 2010s with millions of man hours spent on web components and starving other directions of resources or actively hindering them (e.g. scoped css was continuously postoponed because it's highly incompatible with Shadow DOM) while pushing everything into Javascript (and partly breaking JS e.g. with the bolted-on class-based OOP).

It remains to see if Google's complete dominance breaks the web further

Why is that straightforward? As an example, right now every year on Steam there are thousands of games released. A lot of them are just shovel ware that nobody ever plays, but it does end up hiding actual quality stuff in the noise. Same thing happens in app stores. Gatekeeping that limits opportunity is bad. But gatekeeping around quality is very good. Wanting your software to be written by someone who cares about software and has expertise is, to me, more straightforwardly good.

Right now people are blaming vibecoding for decline in a lot of mature software products, whether that's fair or not (I think it's frequently unfair). I think there's a possibility that's going to morph into "AI First" companies being seen as poor quality brands. Already we see in games that when listed they have to disclose if AI was used or not, and if it was, it damages the credibility quite a bit.

As long as it’s “for you” or “small time”, there really isn’t a problem at all.

The only real downside so far to LLMs (ignoring environmental concerns) is when they’re heavily used and left unrestrained to go play with financial data, healthcare data, PII, anything with real consequences when it breaks. If a person is using it to automate their life. If a father is using it to help their kid with accessibility issues speak. If an artist is using it to help them write code so they can make a game. These are all good things.

You might think it’s shovelware; but the creator of those things is now super excited that their vision was made or their niche issue was helped, when no one else would.

Big corporations behind LLMs are taking it all.

  <!DOCTYPE html>
  <!--[if IE 8]> <html lang="en" class="ie8 no-js"> <![endif]-->
  <!--[if IE 9]> <html lang="en" class="ie9 no-js"> <![endif]-->
  <!--[if !IE]><!-->
  <html lang="en" class="no-js">
  <!--<![endif]-->

I still don’t understand this perspective, how is it good when a growing portion of stuff that’s built is straight garbage?

Consider indie games. If there are 10 of them and 5 are great, you don't need any filter. You look through 5 great and 5 not so great games and end up with 5 great ones.

Now go to a world where indie games explode. But only 1 in every 100 are great. There are now 100,000 games, but most qualify as very low quality. There are now 1,000 great games (and a few of these might be the perfect game you dreamt of), but if you don't have a filter and are buried under 10s of thousands of horrible games, things feel worse.

With a filter, you now live in a world where you can easily find most of those great games with only a few lower quality ones showing up. So as long as the filters that exist, whatever they might be, can handle it, more is better even if quality drops.

Unless the quality extremely fast, say my previous example of 100,000 games but only 1 in a million was a great game. I think this level of quality drop is extremely unlikely. Instead, I suspect the real problem is if the filters can keep up, because they depend upon human effort, so it is possible to hit a point where they are overwhelmed and stop functioning properly. That's when things get worse. As long as the filters hold, more building leads to better outcomes even with a drop in quality.

Just open Steam, PSStore, Nintendo store.

Still doesn't.

OP writes about doing stuff ”properly” and how “using frameworks” was somehow worse.

Having a framework that is built by actual experts is much better than every “self proclaimed expert” building his own crooked thing.

Being able to switch developers between projects easily is also good for developers. I can switch companies on a whim without having to learn “crooked way of self proclaimed specialists”.

There are, roughly, 3 tiers of developers with regard to any such labor saving tech (js libraries etc.)

People who could do a good job low level and can do it faster with libraries. People who couldn't, or couldn't be bothered, before the libraries, but can now accomplish things. That is the good part. And then there are the unwashed masses, who couldn't dream of accomplishing anything on low level but now can, and who at least in case of JavaScript far outnumber the previous category. Like when I messaged a webmaster whose side would download an uncached 3mb script blob on every page load (it was their script, not ads), to render few paragraphs of text, and they responded that it was by design and the script couldn't be cashed because some variables in it changed based on time, and that is so large because it contains features necessary for other pages that have more than text. I think we'd all be better served if these people pursued a more appropriate career, for example in the roadside trash pickup.

It remains to be seen how it goes with llms, but personally I'm not optimistic.

I'd read it kind of like 'The man and the butterfly' story. Or the Kant passage about how doves might wish air didn't exist, without realising that friction is exactly what permits them to fly.

Less of an accident than a byproduct of the unique ecosystem the web lives in (which is a positive!) Compare to say, backend development. If I said database indexes are deeply inconvenient and that I shouldn't have to make them I'd get laughed out of the room and justifiably so. But by comparison when a developer says "I don't care to learn CSS" folks nod their heads in agreement.

The really weird gaps and inconsistencies just make it to untrustworthy. I spend so much time vetting all the outputs that it often cancels out the time it saves me, and I find enough errors that I don’t have an incentive to streamline things/not vet it.

Both have been lost; good riddance the former, but I miss the latter.

Some of it is for sure (CSS, while I actually quite like it, isn't perfect).

However it's fundamentally harder to get the basics right in front end than back end because:

- You don't control the environment (meaning "browser quirks" are actually inevitable to some extent)

- You don't control the screen size and resolution of the device (meaning responsive design is not accidental complexity, it's inherently a somewhat complicated thing you have to address)

- Internal state is often visible to users (an API can be a complete mess internally as long as it returns the correct JSON in a reasonable time. Not so with frontend)

Compare that to backend where you control everything except any external APIs you need to use, it's chalk and cheese.

The reason the market doesn't value front end skills isn't because they aren't difficult or valuable - a really slick front end is worth its weight in gold.

The reason is it's almost impossible to tell in a 1h interview if someone is actually good at front end or not, relative to back end coding tasks which are more deterministic

It depends. My country (Germany) introduced accessibility laws recently which enforces you to build everything public with accessibility in mind. If a page doesn't meet the expected standard you can get extremely high fines.

Is it? More than a decade ago there was a Cambrian explosion of software, Flash alone was the defining force of indie gaming industry. And now what? We have so much shit/shovelware that nobody wants to touch with a ten-foot pole.

No it's not, its the opposite actually its very bad and leads to far far more noise in the system to sort through to find value as someone who's competent.

The users are also entitled to hate your website or app. At what point do you admit you're just making excuses for cheap and sloppy work?

The reality is probably bimodal. The people who are benefiting are benefiting a lot, but they're likely in a minority. The majority will be tokenmaxxing at great expense and spinning their wheels in real terms.

But there's no hard research to prove that.

Considering the huge sums involved, the absence is interesting.

Reality is certainly bimodal today, but that's because as an industry we're lagging behind capability. We're in the early days of the innovator's dilemma S-curve.

Only because you've not invested time[1] to learn a11y, but that is par for the course: LLMs are pretty good at impressing people without a deeper understanding of a field with its statistically average outputs.

My hot-take: one shouldn't oversee an LLM task whose output they are unable to evaluate.

1. And you don't have to! We have limited time, accessibility is broad, there are numerous standards, and screen readers can be unergonomic, to put it lightly. But a human has common sense, and can care. I doubt there's enough a11y training data to match a caring human testing and thinking through interactions. Sadly, human software QA is now threatened with extinction.

It most definitely is not.

This reminds me of the Upton Sinclair quote: “It is difficult to get a man to understand something when his salary depends upon his not understanding it.”

LLMs feel threatening to anyone who had an edge by knowing how to navigate domains with a lot of weird and complex behavior. It’s nice to feel like businesses need you if they want to solve a problem. It’s scary when a cheaper solution arrives that does 70% of that deep knowledge navigation at 1% of the cost.

Also reminds me of that episode of Star Trek TOS 'The Ultimate Computer'

And the STTNG episode 'The Game'

Einstein was correct, the only thing in the universe that is infinite is human stupidity.

That is why I feel threatened by LLMs.

It's debatable if the same should apply to the vast majority of software that is less critical.

How are you supposed to learn without doing? Who sets the bar for when you have achieved understanding?

And finally, in specific instances of creating front ends that are inclusive for users, I would argue that being willing to receive feedback and improve is vastly more important than getting it right on the first try.

Some people are writing the Netflix homepage (where an outage costs millions of dollars), and some people are writing a blog for three readers.

https://medium.com/@amanat361/shamir-secret-sharing-the-stor...

Absolutely no-one is concerned today about what happens when you dip out of connectivity because fast mobile connectivity was not abundant in 2007 (the iPhone was only released that year), which obviates the "this will never replace a USB" criticism. Mobile made a whole new class of businesses possible.

a ton of countries have been selling real stuff for basically nothing to the states to get some dollars back.

i think canada is better off keeping potash and oil and copper and so on than sending it down south, and the chinese are better off using the manufactured goods than selling them for usd

I imagine there are still products they want from the US.

But AI does indeed make it faster and easier. Why sift through the changed lines and hammer down the edge cases yourself if you can get an AI to do it?