12 ms·

There's no reason for software to be slow anymore

• luciana1u 1mo ago
  [flagged]
• eviks 1mo ago
  Great news, let's just wait an eternity for this myth to morph into reality!
• ungreased0675 1mo ago
  But software seems to be getting slower and less user friendly by the hour.
  • stopIiiiit 1mo ago
    Because it's not built with client side optimization in mind any more. It's built with circular investment in mind. Big tech funds startups (through obfuscated legal and financial means) and that funding goes straight back into big tech cloud hosting and SaaS services.
    • rochak 1mo ago
      Isn't this just enshittification? Where money is the driver, enshittification is just bound to happen.
      • stopIiiiit 1mo ago
        If that euphemism makes sense of it for you, sure.
      • an0malous 1mo ago
        The private equity and venture capitalist playbook has always been enshittification: you either take an existing high quality product or innovate one subsidized with investment capital, then once it’s time to flip the business you 10x the price and cut costs (which usually cuts quality). AI is the perfect tool for enshittification, because it can get you 80% of a finished product with a fraction of the costs it used to take, but the last 20% takes 2-5x times longer. So you just ignore the last 20%, make it up in volume by producing 100 mediocre products instead of 1 great one. And that’s basically the state of the tech industry right now. I don’t think it’ll be like this forever, I think there will be better ways to collaborate with AI rather than wholesale delegation and prompting. But for now we’re stuck with mass enshittifation. People who have no sense of quality, taste, or craftsmanship don’t even understand, they skim over some generic blog post from Claude that takes five paragraphs to say one thing or watch the Coca Cola AI ad and don’t event notice it’s a different train in every shot and they think it’s so amazing. I hope this isn’t just the way things are now.
  • mortenjorck 1mo ago
    Both can be true. AI SDLCs simply compress the same incentives that were always there: you could invest in optimizing your architecture and improving your UX, neither of which make for big bullet points that close sales, or you could invest in new features that do. The investment that was previously measured in months of developer time may now be measured in token spend across days, but the underlying dynamics shaping where it’s directed haven’t changed.
• tobinfekkes 1mo ago
  Wow, my browser's Reader Mode saved my bacon on this one. Otherwise, I would have left immediately. I'm all for speedy, simple, plaintext websites, but it is a negligible amount of work in 2026 to throw some barebones CSS in and make it approachable.
  • beyonddream 1mo ago
    I don’t know why you got downvoted but you have a point. It looks as if OP doesn’t write for readership and his posts contents have similar characteristics of reckless abandon for conventional norms for a tech post. Too many cross references and link-backs to his own other articles that makes it really hard to follow the main thread of the essay.
    • phist_mcgee 1mo ago
      Dan Luu is a bit famous around HN. I think he might subscribe to the philosophy of everyone should style websites however they like and not be prescribed by the author.
      • markdown 1mo ago
        Nah, he's just trying to be different. It's vanity. He's had a usable website in the past. This one is explicitly made to be shitty. "Look at me, I'm such a geek" energy.
        • tom_ 1mo ago
          His site has always looked like this, i'm sure of it. This is what sites look like if you just write them as text. Not everybody knows how to use sql or css or java or whatever thing it is that lets you pick the font.
          • markdown 1mo ago
            I'm almost certain he used to have a reasonably styled website. I just tried to look it up but it looks like he's excluded the website from WayBackMachine. > Not everybody knows how to use sql or css or java or whatever thing it is that lets you pick the font. lol at the idea that Dan Luu can't add css to his website by copypasting some links into his html. He could make the site readable in about 3 mins and never have to worry about it again. <!-- Google Fonts --> <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto:300,300italic,700,700italic"> <!-- CSS Reset --> <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.1/normalize.css"> <!-- Milligram CSS --> <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/milligram/1.4.1/milligram.css"> BTW this is just the first such library I found. There are lots of 'em, and all very well documented, requiring less knowledge to use than what it takes to publish a blog... which he's mastered.
• measurablefunc 1mo ago
  There is no reason for it to be non-extensible either and depending on the use cases people might want to trade speed/optimization for more runtime customizations which will inherently be slower than pre-baked SIMD regex and whatnot.
• thomasjudge 1mo ago
  who is Jamie Brandon
  • yla92 1mo ago
    It is https://www.scattered-thoughts.net/ https://www.scattered-thoughts.net/
• bell-cot 1mo ago
  The vast majority of users - weighting by the profits they generate for software companies - obviously don't care about "slow". And Munger's Law never cares if you hate its consequences.
• killbot5000 1mo ago
  As long as there’s a trade off between experimentation and performance, software will always be slightly too slow.
  • phtrivier 1mo ago
    And now the other aspect of the trade off is token budget allocation. The author seems to be in a situation where you can burn as many token as you want. I don't know if that's a general situation. (Even if you don't care about the environment impact of your computations, there is a dollar bill associated, and _someone_ cares very much about that.) I can foresee a situation where devs will have to decide on how they allocate a fixed token budget - and then, faced with the option of "burning tokens to add a new feature requested by a customer for tomorrow's demo" or "burning tokens to maybe make the app faster in some edge case", the trade off will look a lot like the ones organisations made with human dev time. This assumes that tokens are not going to get dramatically cheaper. I can't predict the future, but I don't see a path to that (or, are local models, and "a TPU in every machine" going to make the question irrelevant?). I can definitely see a path were tokens get massively more expensive (let's meet six months after anthropic's IPO and check :D)
• raincole 1mo ago
  100% sure software in the coming years will just feel slower and slower.
  • Grombobulous 1mo ago
    I’m a lot more optimistic now that RAM is scarce. A lot of focus will be on maximizing software performance. See: iOS 27. It’s faster than the previous version, even on very old phones. I also think AI will contribute to removing a lot of the tedium surrounding optimization.
    • champagnepapi 1mo ago
      People these days are saying “don’t look at the code”. People are shipping all sorts of weird architectures, non-performance code, etc. I wish that the ram scarcity would drive more performant software however I just think that the way people are shipping software currently will not lead to this
      • 0x20cowboy 1mo ago
        > People are shipping all sorts of weird architectures, non-performance code, etc. And they weren’t before AI?
        • champagnepapi 1mo ago
          I'm not saying that folks weren't doing that prior to generative AI! I'm saying that the rate at which this is being done is much greater than before.
    • wlesieutre 1mo ago
      Is iOS 27 particularly impressive, or was iOS 26 a shitheap? Maybe a bit of both.
    • senderista 1mo ago
      It fucking better be faster, iOS 26 basically bricked my iPhone SE, which had never been the slightest bit laggy or glitchy before that cursed update.
• supriyo-biswas 1mo ago
  Well, at least with the RAM crunch that the AI boom has caused, I hope there will be some sort of pressure to write efficient software, otherwise device manufacturers are quite fucked.
  • newsomix9xl 1mo ago
    Yah, maybe $1k/dimm on 32 dimm system is a slight price bump.
  • jongjong 1mo ago
    I've been hoping for this for my entire software engineering career but it never came. It's messed up. Sometimes it feels like everything in the universe is aligned to ensure that skilled software engineers lead horrible lives full of anguish, frustration and powerlessness. It feels like the economic system creates incentives which go against efficiency. So then it makes sense that software engineers would be most impacted. There's a weird duality to our job; it's supposed to be about automation and efficiency but in reality, engineers who make the most money are those who create unnecessary complexity because it creates better lock-in and thus gives them more leverage in negotiations. And the tech monopolies they work for never seem to run out of money no matter how much enshittification occurs as a result. Same perverse incentive for open source projects; engineers who lead projects that are full of bugs can charge more consulting fees and sell more enterprise licenses to work around the issues. And engineers are often forced to use shitty tools by their employers so we're always stuck between a rock and a hard place with limited control over our output... Which we are blamed for when things go wrong but never given credit for when we pull heroic feats because those achievements are often overshadowed by missed deadlines resulting from being forced to use shitty software. Adoption and quality are orthogonal, unfortunately. Worst part is that nobody listens to us. Business people with money only listen to engineers who have money; who are mostly merchants of complexity. Engineers who care about efficiency have no voice in this market.
  • WCSTombs 1mo ago
    Yeah, I've been thinking this as well. I have some optimism, but not with high confidence. The exponentially increasing power of computing hardware up until this point is often cited as the reason performance optimization has been sidelined in the software industry. Now that there's a definite hiccup in that trend, I'm hoping programmers will remember that software actually can be fast and memory-efficient, and that poor design choices that lead to bad performance are exactly that, a choice. The author of the article definitely seems to think LLMs are what enables this to happen, but I personally am much more skeptical of that. I think what it really needs is bringing engineering back into software, not just throwing LLMs at it and calling it a day.
• newsomix9xl 1mo ago
  One article said secure software was here because of AI, this one says it can now be performant. Yet when I ask for code it writes, by default, both slow and insecure code that mostly works. Kinda. As I try to get AI to rewrite it into more secure, less bloated and optimized code is when it starts to randomly crash. Then I read articles about how AI is "moving too fast" and cry.
  • y1n0 1mo ago
    It's all about the test suite. The test suite becomes an executable specification, and the better the spec, the better the results you can get from AI.
    • moron4hire 1mo ago
      If you have such a test suite then you really don't need AI to write the code for you.
      • thorian1828i03 1mo ago
        Writing a benchmark test is about 100x to 1000x easier than writing optimizations. A benchmark test can be as simple as: func Benchmark(b *testing.B) { for range b.N { runCodeUnderBenchmark() } } Actually optimizing the runCodeUnderBenchmark() function is far more difficult.
    • jongjong 1mo ago
      It's part of it but you need good systems thinking in order to write good tests. The kind of thinking which requires years of software engineering experience to acquire. Also the architecture really matters now because a poor architecture will lead to more weird edge cases and require more exotic tests to plug all the holes.
    • devin 1mo ago
      The very first thing many people did with AI is start calling the automated tests it writes good enough to capture the desired behavior. Writing tests isn't a whole lot of fun for most, so now the thing that it is supposed to help ensure we're not evolving our software into piles of trash is, in fact, one of the most neglected parts of vibed out codebases.
• nemothekid 1mo ago
  This makes sense for a verifiable task like a regex engine - but those are clearly defined and I doubt an LLM will have a meaningful speed increase over current human regex engines. Anything else kind of just feels like "make GTA 6, make no mistakes". The ability for you to write fast and correct software is really going to depend on well you can specify your problem, and having the ability to specify correct programs in such detail an LLM can reasonably performance tune it is a big enough reason for me to believe there will still be slow software
• gravypod 1mo ago
  I recently built a piece of code which downloads a bulk set of data, indexes it for search, and then serves a pretty web UI on top of this with the help of some AIs. Normally I would have reached for sstables, sqlite, etc. This time, because the lookup patterns actually would not have been too efficient on sstables and SQLite would have been overkill, I had an agent take the data structures, pack the text effectively, and build a prefix tree for fast auto completion from the search bar. It was great. I could have done this all before but I wouldn't have. I would have felt sqlite was fast enough. The resulting web server is significantly faster feeling (because the optimized lookup speeds) than an sqlite implementation would feel like. I think engineers building very complex systems now have a lot of performance knobs to twiddle that would have just been too costly for human effort. Since we constrain the responsibilities of the agent slop is less of a problem. We relegate it to defined tasks with clear API boundaries and test harnesses.
• panny 1mo ago
  >LLMs are causing slow, bloated, code are going to eat crow once they re-write everything in super-optimized assembly LLMs have caused such an increase in ram prices that pine64 is no longer making linux machines. When you can't afford RAM, as a direct result of LLMs, it's going to make your assembly app slower too. Sorry, this is the future you chose.
  • pdimitar 1mo ago
    [flagged]
• jeffbee 1mo ago
  Eh, not sure. Very few humans do software optimization productively, so I'm not optimistic about machines built by humans, either. Every encounter I've had with agentic optimization involved trying to apply a bunch of myths to an existing code base, in a way that seemed cool (unrolling loops, eliminating apparent branches, SIMD) but which was all pointless because the only credible optimizations were going to come from doing fewer loads and taking up fewer itlb slots and stuff like that.
  • tekne 1mo ago
    Data point of one, but after a few months of uselessness, I have managed to get some pretty serious, measurable performance improvements with AI optimizations -- order-of-magnitude speedups of business critical processes which took days as well as significant latency reductions. But you need a really solid workflow, solid benchmarks which run quickly, and a lot of tokens -- plus a rigorous profiling workflow.
    • jeffbee 1mo ago
      What I want is the PMU in the loop.
• mtgh2s 1mo ago
  we should just have the LLM rewrite everything in Rust :D problem solved
• Lerc 1mo ago
  Giving an LLM a program that does a well defined thing correctly and asking it to make a faster version and a crapload of tests to show that it performs exactly the same task is a great way to burn through a bunch of tokens and getting a faster program in return. I currently have one running working on a multi path problem trying to make an A* heuristic that produces the same or better score for search time, paths crossed, corners taken (plus a few other metrics, like proximity of opposite direction corners of unconnected paths.) I have another where I'm testing how well it can iteratively rewrite the same program without regressions and successively stricter resource conditions. Instead of progressively adding lines of code to make an over engineered behemoth, starting over with the previous version as a template of functionality lets it consider the problem increasingly holistically
  • devin 1mo ago
    I would be genuinely interested to see how it evolves the same program over a large number of generations. Given a whole lot of software is more a collection of programs rather than a singular "program", I have to imagine that the outcomes would be vastly different in shape when dealing with smaller targeted, articulable-in-a-few-paragraphs programs vs many-years-of-business-domain layered programs.
• 4lx87 1mo ago
  Jevon's paradox implies we're getting more fast software, and more slow software. Sturgeon’s law implies the ratio will remain the same. 90% of what ships will be slow, buggy, slop. Just as it was before LLMs.
  • paulhebert 1mo ago
    I wonder if AI has changed the 90% rate. From my perspective it’s already increased the ratio of what I’d consider bad. I haven’t seen as big of an impact on the “good” side. People with attention to detail and craft can use it with great results but they’re not pumping things out at the speed of the slip slingers.
  • dandellion 1mo ago
    I think this is the most accurate take on this thread. I've written super optimised code in assembly and SIMD. But only for contests never at work, because I've never had an employer that cared to optimise things that far, they just wanted cheap software that worked just good enough to get the job done. Even in places where they actually cared about quality would usually prefer adding a couple features over optimising things that much.
• hardaker 1mo ago
  What if we need pretty, rounded, softly opaque corners on all our transparent windows hovering above a gently shadowed background?
  • m463 1mo ago
    apple might sue you for infringing on their primary money maker
  • userbinator 1mo ago
    The demoscene could do that, and much more, on 90s hardware.
• 0xbadcafebee 1mo ago
  "There's no reason" being very different than "we can now do the thing easier". There are still tons of reasons for software to be slow, the biggest of which is priorities. If you want your software to be fast, stop writing it in Python and TypeScript and instead write it in Go, Rust, C++ or C. But nobody's going to do that, because humans are emotional creatures who get attached to things (like programming languages). Or if you want your software to be fast, stop spending your time and money (tokens) on features, and start spending it on profiling log replays to find a bottleneck causing a 50ms delay for the 95th percentile. But nobody's going to do that either, because how slow is too slow? Answer: when it's slow enough to scare the shareholders or annoy the developer on their high-powered laptop. If you want faster/more efficient software, force it to run on a 100MHz CPU with 512KB RAM and a 56k modem. You'll definitely prioritize speed then.
• jongjong 1mo ago
  > performance work that used to require a person or team that had a rare set of skills can be done by anyone who can type a few sentences This idea is the reason why software will keep getting slower and less reliable. Because it's wrong and yet people believe it. Not only do people believe this, even if they didn't, they would still have the problem that most people (including many engineers) are bad at telling who is a good software engineer. So this means that code will get worse and worse; less performant, less reliable, less secure. It will be impossible to fix because nobody would know what the problems are let alone identify who is able to solve those problems. I don't know how bad it has to get before people understand we have to rebuild everything from scratch on much more rigid guardrails. The essence of the problem is that the LLM does exactly what you tell it. In the hands of a skilled engineer who understands the project, this is a superpower. In the hands of a junior, this is dangerous... Because it will do things that are insecure; it doesn't push back on a user request; it just goes ahead and tries to make it work, even if it's a bad idea and the problem is best solved in a different way.
  • rfgplk 1mo ago
    > This idea is the reason why software will keep getting slower and less reliable. Because it's wrong and yet people believe it. Not even close to being true. Prior to the advent of LLMs writing good SIMD was hard. Writing good SIMD for arbitrary tasks was _extra_ hard. Having the entire application be written with SIMD in mind was nigh impossible, from simple string parsing to data pipelining. Having arbitrary OpenCL/CUDA offloading to GPUs was a monstrous task. And even the people who were experts in these domains didn't have the time to do it in an afternoon. But now you can. You can literally instruct your agent to write SIMD accelerated code everywhere, or to optimize down to it. And it just _does_. > The essence of the problem is that the LLM does exactly what you tell it. This is correct. I implore people to try writing a SaaS with an LLM, but instead of going the classic agentic project style of "design me an app", tell it to use C++ or Rust, use extensive SIMD intrinsics and inline assembly wherever possible. Just off those two instructions the difference in code quality is staggering.
    • jongjong 1mo ago
• ehnto 1mo ago
  One of the biggest causes of slowness is just waiting for web requests. The fact that so much software is either online or built using the same stack even if it isn't, puts all that software in this blocked/waiting state constantly while using it. Anyone not in the US feels this even more since so much online is US hosted, 300ms for every little interaction adds up quick. If your software has the affordance of a waiting dialogue or loading wheel for many of its UI controls, you are building with this default blocked assumption. Even if you are building something web based, ask yourself if that's actually necessary for your software or if you could build it differently to avoid constant UI blocking.
  • hsn915 1mo ago
    It's not very hard to engineer software with these two constraints at the same time: * Must feel very responsive * Network requests can take up to 500ms end to end
    • alightsoul 1mo ago
      That's why phones and windows use animations. You can also use intersitials related to the product you sell. Users are usually fine seeing many changes on the screen quickly because it gives the impression that stuff is happening on the background. For example in the interstitial, use an animation that takes up a small portion of the screen and not just a simple spinner or loading icon. Something more complicated with 2 or more things moving or changing at once.
      • ddejohn 1mo ago
        > Users are usually fine seeing many changes on the screen quickly because it gives the impression that stuff is happening on the background This gave me a chuckle because I personally hate things like watching the browser jump through 50+ redirects when logging into a website.
        • alightsoul 1mo ago
          My bad, I mean the interstitial. Like it should stay for at least a second to not make it jarring. People believe computers need to think so you can't make things too fast either. Not the interstitial and not the app either, to the point you sometimes have to deliberately slow down the app, add latency to make people trust it because it "gives the computer time to think"
• datsci_est_2015 1mo ago
  Feel like this is the equivalent of a traffic engineer standing at the grand opening of the 5th lane for the highway saying there’s no reason for traffic to be slow anymore. That is, there’s a misunderstanding of why software (traffic) was slow in the first place, and it has nothing to do with our ability to generate code (number of lanes), even if that code is “high quality”.
  • w-ll 1mo ago
    you dont mesaure the quality of a plane by how much it weighs. but yea i think everything is rot to the core. app to os if just wackness that nobody cared about.
  • Grimburger 1mo ago
    Still a struggle to get coworkers to write docs or tests despite it being effortless. At the end of the day its a mindset.
  • efsavage 1mo ago
    Sorry I can't resist the pedantry but a traffic engineer knows better than anyone that adding a 5th lane (often even a 4th) won't improve traffic except in fairly specific circumstances. :D
    • paulddraper 1mo ago
      But it will definitely improve, either speed or volume.
      • dwattttt 1mo ago
        Locally. Under many circumstances. But always? That's not a universal law, as it's a part of a larger system that may perform more poorly if this leg provides more traffic.
      • coaksford 1mo ago
        This isn't categorically true either, the real world is delightfully complicated, far more so than you imagine. The way cars interact within a road, as they enter an exit the road, or how they choose their route can all create conditions where adding a lane only makes traffic worse and can reduce both speed and volume during peak traffic hours.
• HumblyTossed 1mo ago
  Incentive has shifted. It’s now more important to worry about “developer productivity” and churning out as much code as quickly as possible than it is to spend time optimizing that code.
• aislopdududu 1mo ago
  [dead]
• shoopadoop 1mo ago
  In my experience AI coding is often about making lots of additive changes without a lot of (or any) thinking in advance. Not sure how either of those things are conducive to performance
• mccoyb 1mo ago
  Here's this boiled down: > A stochastic search process with an executable optimization objective over space of programs S can only maintain or improve the objective This is superoptimization. We've known this since the 80s (Massalin, STOKE is more recent: https://github.com/StanfordPL/stoke https://github.com/StanfordPL/stoke) The only novelty is that the proposer is now way better with LMs. Further, there's a large number of reasons for software written by agents to be slow: - LMs still don't do data or hardware-oriented design well out of the box, and therefore if you're engaging in any sort of serious novel work, beyond porting an extremely well-understood program with extremely well-understood workloads, you're going to be spending hours tracking down bad allocation decisions (c.f. why TigerBeetle doesn't use agents), which are often the root of evil (before you'd reach for anything further) - The knobs you'd need to get serious performance are nearly unreachable in languages which LMs are good at (even Rust requires a discipline that the default language doesn't enforce). When you drop into the lower realms, you're trading consumption context for access to these levers. The levers are also "soft": you find yourself writing a bunch of skills, and tools to try and enforce the discipline. The reality is to get performant code (quickly) out of an agent, you need to know how to write performant code (and you need to know how to surface the information that you'd use to create a verifier for such a thing to the agent), which 99% of developers do not know in 2026. Sure, agents can teach you how to do this -- but it's one of these things where iykyk. Experience: I've poured 10s of billions of tokens into Zig with the best agents and I have the time and space to try these things. If you want to start learning the discipline, I'd recommend matklad's + TigerBeetle blog -- as well as hardware-oriented design.
  • Aurornis 1mo ago
    > - The knobs you'd need to get serious performance are nearly unreachable in languages which LMs are good at (even Rust requires a discipline that the default language doesn't enforce). When you drop into the lower realms, you're trading consumption context for access to these levers. The levers are also "soft": you find yourself writing a bunch of skills, and tools to try and enforce the discipline. Hasn’t been my experience at all. The latest LLMs can knock out assembly optimized subroutines and benchmark 100 different variations faster than I ever could dream of.
• theturtle 1mo ago
  [dead]
• theturtle 1mo ago
  [dead]
• intrasight 1mo ago
  I've been using computers for 4 decades. They have gotten no faster. The nuclear plant computer system we built in 1989 had to present selected screens in 1 second. I don't think any apps I use today can do that.
  • paulhebert 1mo ago
    It’s all incentives. I’ve worked on web projects where the people in charge cared about performance. It’s easy to get sub second speeds if you start with that goal. I’ve also worked on projects where the people in charge added 1mb client-side mapping libraries to render a static map and ignored my push back. Those website were slow
    • gwd 1mo ago
      This. The author talks about the fact that now they can try far more experimental optimizations than they could before. But they already had an architecture with efficiency in mind, and were trying optimizations, to begin with. The kind of company that ships web UIs that take 5-10s to do some action 1) don't care or aren't capable of good architecture 2) don't care or aren't capable of doing the simplest low-hanging optimizations.
  • alightsoul 1mo ago
    At some point, probably in the 1980s, people probably decided that computers could update UI fast enough, so any additional compute power or speed has been used for other things like making it prettier or reducing development effort or time, and now ai
    • catdog 1mo ago
      The problem is that the UI speed largely was not kept at that level but considerably slowed down again despite exponentially growing compute power.
      • duskdozer 1mo ago
• m3kw9 1mo ago
  Its more about discipline because you now have so much more option for that power, not just optimization. The engineer or the manager can choose more tech debt, then LLM's power is neutered because the complexity to optimize has increased by that much, and somehow evens out, and you are back to square one.
• jjcm 1mo ago
  This speaks to me. I've been running an autoresearch loop the past couple of days to improve the load time of my various projects' frontends. I've been really, really impressed with how effective this is. I went from a 4s load on simulated slow 4g to ~750ms: https://image.non.io/speedup-graphs.webp https://image.non.io/speedup-graphs.webp Side by side vid of the results: https://video.non.io/speedups.mp4 https://video.non.io/speedups.mp4 This was for https://non.io https://non.io, which is something I had purposefully written to be as fast as possible (hand wrote all the comopnents, didnt even use react). I've been considering creating a skill / utility to do this based on learnings from the speedups - would others find this kind of thing useful?
  • VladVladikoff 1mo ago
    > This was for https://non.io https://non.io Maybe hugged but feels really sluggish to me for it is.
    • jjcm 1mo ago
      These are the stats I'm seeing: https://image.non.io/7a8adcb1-2a17-4e2c-b213-d0c3e173a1d5.webp https://image.non.io/7a8adcb1-2a17-4e2c-b213-d0c3e173a1d5.we... Should note the server is on USW and I don't have edge servers for it at the moment.
      • VladVladikoff 1mo ago
        https://pagespeed.web.dev/analysis/https-non-io/6mtvojtvvy?form_factor=mobile https://pagespeed.web.dev/analysis/https-non-io/6mtvojtvvy?f... Quite slow imho
    • throwitaway222 1mo ago
      Never visited before and the site was HN load speed. Very fast.
  • ltbarcly3 1mo ago
    Why is it so slow? Like clicking around this is a very simple site, it seems like the fade in and fade out, besides being jarring and annoying, is just adding load time.
• canada_dry 1mo ago
  I regularly support Windows users and when I do, I cringe at just how awful the experience is! (My daily driver for the last decade have been various flavours of linux) High end Windows 10/11 machines (like my Alienware I9 w/ 64GB mem + RTX4090) seem a bit sluggish. Low end machines with Windows are absolutely painful to use! I've install debian onto my fairly ancient Lenovo X201 Tablet and it is exceptionally snappy.
  • TacticalCoder 1mo ago
    > I've install debian onto my fairly ancient Lenovo X201 Tablet and it is exceptionally snappy. I'm running Debian since Debian 1.1 (1.1, not 11). My install has always been very lean: a minimal WM I love. Computers have only ever gotten fast and Linux more optimized. It's extremely snappy indeed and feels like it. The problem is what happens inside browsers: are great many websites are just lame. So many pointless connections to so many pointless "telemetry" services, trying to track your every single habit/clicks. Just open the dev tools and look at all the trafic exchanged: that's where the bloat is. The SV JavaScript "punch the monkey" ads bros at work.
• IshKebab 1mo ago
  Yeah.... maybe. I think AI is still too prone to go down rabbit holes and not understand the whole picture well enough to come up with good optimisations. It's probably good at micro-optimisation, e.g. pre-allocating arrays. But is it going to realise that you don't need that array in the first place? I dunno. On the other hand it does mean there's no excuse for writing your program using Python or Electron or whatever, which will have a big effect on performance.
  • paulhebert 1mo ago
    The reason for using Electron is to write once and run everywhere right? I get that LLMs would make it faster to write distinct copies for different operating systems and maintain them both but thats still more costly than a single system. Sorry if I’m misunderstanding the goal of Electron but it still seems cheaper and easier (although admittedly worse than multiple native apps)
    • IshKebab 1mo ago
      Yeah that's my point. Maybe AI will lower that cost to the point where it makes sense to write e.g. a native Slack app. I dunno, we'll see.
      • punarinta 1mo ago
        There is a native Slack client actually. Fast and with good feature coverage, it’s called msga.app
        • IshKebab 1mo ago
          Aha exactly what I was talking about. Vibe coded in a few months. Maybe it has slop bugs but if you have as many employees as Slack it shouldn't be that hard to whip into shape. There's no excuse for Slack not having done this themselves.
  • yboris 1mo ago
    Are you suggesting Electron is slow? What evidence do you have? There may be a +200ms start up time compared to a native application; is that so bad? Besides a bootup that is no longer than your browser's, everything else inside an Electron app can be identically fast to a native application. Please be a better filter - do not spread bad memes.
• briheet 1mo ago
  i can pore all my time, agents running profiling, workloads and so but no one gives a damn. tried the whole year, still do for my personal projects
• bensyverson 1mo ago
  Much like security, optimization is now a function of token spend—which in some ways means it's a function of care. The reason why software may continue to be slower or less secure than it could be is simply that no one cares enough to invest the time and money in improving it. Off-topic, but Dan, in the name of all that is holy, throw a `max-width: 40em;` on your blog!
  • em3rgent0rdr 1mo ago
    Reader mode (built-in to both Chrome and Firefox) does the trick.
  • hombre_fatal 1mo ago
    That said, performance and security considerations can be automated by a reusable harness and I think within six months it will just be built in to things like claude code and codex the same way you might tack on a performance/security section to your project's AGENTS.md. A crude example is how, when building a large forum project years ago, I had a checklist I ran on every new http route: authentication, authorization, validation, etc. just because it's trivial to forget one of them. Yet now the LLM can come up with a lintable/verifiable way to ensure every route has the whole kit by construction. Almost every way I feel like I can provide unique value to the automated AI workflow (aside from deciding what to build at all, and taste) feels like it can be automated by better markdown.
    • tomveber 1mo ago
      The checklist half automates cleanly, you can lint that every route calls authorize. It won't catch authorize being handed the wrong policy, which is the one that ships. And when I put a second model on review duty, the common failure is it agreeing with the first model's misreading of the spec, almost word for word. So I'd expect the forgetting class of bugs to mostly go away and the misread-the-spec class to sit exactly where it is.
      • hombre_fatal 1mo ago
        LLMs trivially catch these things in review, and if you find agents agreeing incorrectly with each other (weak models?), maybe you need to be doing adversarial review. It's pretty much solved, though I only use sota models. I think for these convos, we need to see concrete fail cases so we can see what you're talking about and whether the truth matches up with the claim.
• 3dedb728-3f77 1mo ago
  How will the user know the computer worked 'HARD', if it is not slow? Do you not add sleep to your programs?
• solarized 1mo ago
  [flagged]
• dionian 1mo ago
  I feel so nostalgic viewing this website. I love the simple old school design. we need to bring it back
• eru 1mo ago
  The article links to "You can just choose how many bugs you want now" https://nolanlawson.com/2026/08/16/you-can-just-choose-how-many-bugs-you-want-now/ https://nolanlawson.com/2026/08/16/you-can-just-choose-how-m... So going on a tangent: an additional mechanism you have that becomes feasible with LLM assistance today is proving your code correct.
• asdfman123 1mo ago
  What about these reasons? - Your boss/most of the market doesn't care if your software is slightly slow - Your boss/the market wants new features It's easier now to slip in fun optimization features when no one's looking, but the incentives are still off.
  • ltbarcly3 1mo ago
    I can't tell if you are saying the market doesn't care if your software is slow, or quoting someone else. Either way it's objectively false and that has been known for decades. Making users wait is a surefire way to make them engage with your product less, and the more you make them wait the less they will use it. If your boss doesn't care about your software being slow he's incompetent. https://services.google.com/fh/files/blogs/google_delayexp.pdf https://services.google.com/fh/files/blogs/google_delayexp.p... https://business.google.com/ca-en/think/marketing-strategies/mobile-page-speed-new-industry-benchmarks/ https://business.google.com/ca-en/think/marketing-strategies... https://medium.com/ft-product-technology/a-faster-ft-com-10e7c077dc1c https://medium.com/ft-product-technology/a-faster-ft-com-10e... https://www.pingdom.com/blog/page-load-time-really-affect-bounce-rate/ https://www.pingdom.com/blog/page-load-time-really-affect-bo...
    • paulhebert 1mo ago
      The market cares. In my experience it’s harder to make your boss care. It’s often been hard for me to make coworkers care as well which is even more frustrating. Unless your job really prioritizes performance and builds in benchmarking people often focus on finishing a feature as fast as possible and ignore performance (and accessibility, bugs, UI polish, etc.)
    • asdfman123 1mo ago
      Experiments demonstrate that increasing web search latency 100 to 400 ms reduces the daily number of searches per user by 0.2% to 0.6% It obviously depends a lot on what you do, but often that doesn't matter.
      • 1mo ago
• aurareturn 1mo ago
  I gave Fable 5 access to the database and the browser and asked it to optimize for performance. Woke up today with 2x improvement and fully tested. The code optimized was mostly written by humans over the years. That code was too cumbersome to optimize by humans so we never touched it.
• deleted 1mo ago
  [deleted]
• anon-3988 1mo ago
  Yes, simply stop using JavaScript and give me static webpages. Done. I don't give a fuck if your website have a nice effect that follows my cursor, I just think about the amount of energy, effort and time wasted on making this demo. See https://deepseek.com/harness/en/ https://deepseek.com/harness/en/ Is anyone really impressed by this gimmick anymore? Just give me a blank HTML with <table>. Its fine. I dont think anyone care.
  • radium3d 1mo ago
    Sites can be fast with PHP and JavaScript. The slowness you see is mostly coming from all the frameworks too many developers "include" willy nilly with code that can only be described as bloat because 99% of it is completely unused, yet being loaded and computed by the browser on every load. That's what you're experiencing on too many websites.
    • rfgplk 1mo ago
      Funnily enough, since most JS frameworks are utter junk, developers are better off instructing LLMs to write pure JS instead. Fun story, I was writing some 3D graphics animations for a website, and the only dependency I allowed was three.js. It ran well, but the site was loading slightly too slow so I told the LLM to optimize. It essentially hit a hard wall and told me something along the lines of "I can't optimize further, three.js is the bottleneck due to blablabla, but you don't need it. If you want I can rewrite it with pure WebGL". I said sure and load times were cut by like 90% and framerate went up too. Staggering.
      • radium3d 1mo ago
        Exactly, that is definitely a better route. Just instruct your agent to not use any external dependencies for the request.
• Kuyawa 1mo ago
  Next time you ask your AI of choice to build an app, please tell them to use plain language without frameworks at all and keep modules to a minimum (ie. node express, ejs and pg, nothing else) and you will see a huuuuge difference
  • esikich 1mo ago
    Yep, I feel like there's less of a reason to use frameworks now that you can just have it bash out only the needed stuff on its own. I've been able to make some really really tiny C tools and I'm absolutely loving it.
    • albert_e 1mo ago
      Good point. Maybe if this philosophy / approach has a catchy name it might be more widely adopted and we all can have better more performant web and apps.
    • hirvi74 1mo ago
      My experiences might mirror yours to some degree. I somehow managed to avoid the entire SPA scene. I feel so vindicated because I am absolutely zooming with my tried and true Vanilla JS these days. I have tried React, Vue, Angular, and ever just plain TS, and I hate them all.
  • alightsoul 1mo ago
    I had the same thought a few days ago. Coding agents have rendered frameworks obsolete. Apparently many people disagree though.
    • catlifeonmars 1mo ago
      I like to use frameworks to steer the agent. I constrain it different primitives for different tasks in order get the shape I want without explicitly prompting too much. You can think of it as API driven development
    • globular-toast 1mo ago
• eaftan 1mo ago
  I've been working on a similar agentically engineered regex project called SafeRE: https://github.com/eaftan/safere https://github.com/eaftan/safere https://eaftan.github.io/safere-intro/ https://eaftan.github.io/safere-intro/ Mine is for Java and is intended to be production grade. The first goal is to guarantee linear-time behavior to prevent ReDoS attacks. My collaborator and I have recently been optimizing it to try to surpass native RE2 in performance. It turns out optimizations are incredibly well suited for an agentic loop. You've got concrete acceptance criteria (must show a meaninging improvement on a benchmark case, must pass tests). The agent is really, really good at using tools like a profiler and disassembler, better than I am (and I've been doing this for 20 years). It also papers over things that would take me a while to learn, like how the in-incubation Vector (SIMD) API works in Java. I understand the concept but it would take me a while to understand Java's implementation. The agent can just read the docs and go. The key is creating a good benchmark suite and ensuring the agent doesn't ship optimizations that are too narrow or too focused on the benchmark cases. You also need a really strong test suite to make sure you're not regressing correctness. SafeRE has billions of tests; a subset of several million run on CI, and the others run on-demand.
  • za3faran 1mo ago
    This sounds very interesting. Which JVM profiler do you use?
    • stickfigure 1mo ago
      Not OP, but I went through this last week. I (ok, codex) optimized a hot path in some Java code from ~350ms to ~60ms, which made a substantial difference in "is this whole business going to work". My Java profiling knowledge is... let's call it "antique". I was really not looking forward to ramping back up for this work. Turns out, I didn't have to do any of it. The LLM chose the tools (flight recorder) and even built a JMH (also new to me) harness to experiment with different algorithms. About half of the optimizations were things that I would have figured out on my own; the other half were definitely "wow" moments. The whole thing was done in a couple hours, with just a few back-and-forths. Sans AI, it would have taken a week, with nowhere near the same gain. I'm impressed. "Figure out how to make this process fast" is really a perfect activity for LLMs. And the prompt doesn't really have to be much more sophisticated than that.
• wseqyrku 1mo ago
  - Computer, enhance.
• 0xblinq 1mo ago
  There's no reason for sites to look super ugly, full width and unreadable anymore.
  • jeffreyrogers 1mo ago
    His site didn't always look like that, for some reason he changed it a while ago and now I have to use a custom stylesheet so I can read his articles. It used to be more readable.
• malixp 1mo ago
  [flagged]
• gr_norm 1mo ago
  This needs to be qualified with "to the degree that you have a specification of what that software should do." The better the spec, the more leeway you can give the optimizer. A very thorough spec lets you give the LLM total free rein to run optimization passes over your codebase.
• phyzix5761 1mo ago
  Software will get slower as we do things beyond the current hardware capabilities which is always the case as hardware improves.
  • vinyl7 1mo ago
    We have yet to reach the limit of the radius that we already have https://www.dgtlgrove.com/p/near-the-zero-point https://www.dgtlgrove.com/p/near-the-zero-point
• userbinator 1mo ago
  I was very much on-the-fence and somewhat sceptical with respect to AI-assisted software development and optimisation, until this recent article pushed me strongly into the "believer" side: https://news.ycombinator.com/item?id=49226923 https://news.ycombinator.com/item?id=49226923
• squirrellous 1mo ago
  This doesn’t seem to mention that having AI aggressively optimize software will result in code that is too clever / complex to be maintained by the original human author. For something with a very stable API and can be tested to death like a regex engine it’s likely workable. Other things, not so much. We have enough trouble maintaining AI generated code _without_ aggressive optimizations as is!
• luciana1u 1mo ago
  [flagged]
• gulugawa 1mo ago
  I agree with the headline, but I don't think LLMs are a reliable way of optimizing software. First of all, coding speed is not the main bottleneck. I've been working on my own JavaScript framework. Most of my work is talking to people about challenges they have with web development, doing research on existing tools, and thinking about features to add. Coding more slowly without LLM usage is a benefit because it helps me understand every line of code. The slower pace also helps me think about making things intuitive and reflect on my experiences with React. While my framework is outperforming React, that isn't particularly impressive. On the other hand, it demonstrates how ignoring LLMs improves quality. Also, my monthly token spend is $0.
  • deleted 1mo ago
    [deleted]
• dat999zx 1mo ago
  Most of the time, it's the network related stuff, requests that are slow. But with AI, devs nowadays are chasing the aesthetic vibe, cool animations, forward-backward video on the background relative to the scrolls... Which worsen the performance drastically just for a cool landing page. I mean that could be cool for landing page only but some people put all those animations in the product itself too, which is a pain to use.
  • deleted 1mo ago
    [deleted]
• belZaah 1mo ago
  What makes large things slow is not the individual pieces of code but the way the architecture dynamically reacts to changes in the load. Sync vs async calls, buffers, parallel vs sequential processing. This includes optimizations made: do we want to wait until the call returns or do we proceed anyway and deal with the negative response later? Most developers can’t coherently (ie, with math, graphs and figures) explain, how a connection pool prevents undesirable consequences of brief spikes in incoming requests. And I’m pretty sure AI can’t either.
  • spockz 1mo ago
    It can in general: https://chatgpt.com/share/6a893693-51a8-83ed-86f9-66a1f83cb1b5 https://chatgpt.com/share/6a893693-51a8-83ed-86f9-66a1f83cb1... Whether it can apply it directly from the codebase, I’m unsure and depends on many factors.
  • inigyou 1mo ago
    Can you explain that? I don't think you can explain it either.
• hunterpayne 1mo ago
  "LLMs are causing slow, bloated, code are going to eat crow once they re-write everything in super-optimized assembly." This person doesn't understand how to make efficient code. I can write code in almost any language (with a couple of exceptions) that outperforms "super-optimized assembly". Writing efficient code isn't about the language, and often isn't about the best algorithms either (but sometimes it is). Its about optimizing memory and cache use. And that's orthogonal to anything the author is writing about. Also, LLMs are terrible at optimizing memory utilization. There is just too little training code that does it well and far too much that doesn't. As proof, I'm can literally feel the web getting slower and I bet many others feel this as well.
  • malisper 1mo ago
    > This person doesn't understand how to make efficient code The author is one of the most knowledgeable people about performance there is
    • geraneum 1mo ago
      Seems like author’s main focus recently is AI and agents unsurprisingly, hence the suspicion. But it seems like he has a backgrounded in relevant fields in the past.
    • hunterpayne 1mo ago
      The author didn't write the quote.
      • Kiro 1mo ago
        Just admit that you were wrong instead of this doubling down nonsense. LLMs are amazing at optimizing memory utilization. They have no problem obsessing over fitting as much data as possible onto a single cache line and micro benchmarking cache hits.
        • rrook 1mo ago
          This seems like way too caustic of a reaction, OP is correct. If you actually know what you're doing in $language, and you know how $language wants to emit the assembly or whatever, there's no huge advantage to just programming directly in assembly.
• rfgplk 1mo ago
  LLMs have essentially made any language above the C++/Rust systems level tier obsolete. The only reason you picked a language like C# or Python is often out of convenience of having a broad ecosystem or due to the lower level languages being too hard to master, with too many footguns. The tradeoff being is that you got a less performant implement, while being easier to write. Nowadays, those arguments are dead. LLMs can now write perfect code in low-level languages, that is frankly _safer_ and _exponentially_ faster than implementations in high-level languages.
  • raincole 1mo ago
    Yeah, let LLM write C++ when your team have cannot comfortably write C++ in the first place. This is surely a frankly safter way than human-written C# and Python.
    • rahkiin 1mo ago
      Yes indeed, that will be a much better road to a durable, maintainable, secure and agile product than focusing on product goals in a higher level language with a framework. When will we start using LLMs to write my web backend directly in UEFI and assembler? (Although uefi is an OS, so maybe more fair to exit the boot services)
  • dkersten 1mo ago
    > LLMs can now write perfect code in low-level languages, that is frankly _safer_ and _exponentially_ faster than implementations in high-level languages. Your experience does not match mine. It writes ok code, it does not write good code. I see it leaving a lot of performance on the table, doing silly things like wrapping everything in a global mutex. Or certainly doesn’t write idiomatic code in Rust or C++
    • arto 1mo ago
      Try Fable with a thinking effort of High or more and a good harness. The resulting Rust code is, in fact, excellent. (However, it would also easily cost you $100+ in tokens for a day's work.)
• arjie 1mo ago
  I understand now that most software is slow because of co-tenancy reasons requiring controlling resources or simply because they're safely insulated from competition. e.g. GitHub is the former: you can give yourself a git host and CI/CD system that is much higher quality by yourself since you're probably not using its social features. I think things like Apple's five-finger inward gesture are the latter. Once you could do it and start typing but nowadays it needs to render the animation etc. before keystrokes register. This software is slow because you cannot replace it in MacOS. But all these things will change in time. Hell is other people's software.
  • Nevermark 1mo ago
    > Apple's five-finger inward gesture are the opposite. Once you could do it and start typing but nowadays it needs to render the animation There is no technical reason that animation should take that long. Someone said, "good enough" and let it be visibly slow. The reasons for that could be anything, including non-performant code in dependencies, written by other people. But it just does not take much computing power by today's standards to composite code-generated animation. Somehow, despite year after year of percentage-speed hardware improvements, there are cultural and structural reasons people ship code visibly slower than it needs to be. And faster compute appears to be irrelevant.
    • arjie 1mo ago
      Perhaps the real tragedy is not the animation. It is the fact that previously keystrokes would register even if the animation had not completed and now they do not. Interaction once you've entered a new mode should be instantaneous. Instead we are faced with inputs going neither to the old app nor to the new app. In the prior world, I could do the gesture and type the letters and hit Enter and the animation would not interrupt me from getting to my destination. Now I simply <backspace> <backspace> <backspace> and suffer the ignominy of a software system that does not care about my niche needs and is nonetheless beyond my present ability to modify while retaining all else.
    • jshier 1mo ago
      Making animations faster is one of the main reasons why, despite all the glass effect rendering, the 26 Apple OSes can feel faster than their previous versions. (Not always, of course.) They simply shortened the animations. The 27 versions do the same thing. Of course, this doesn't help all interactions, but it definitely improves the first impression.
• amarant 1mo ago
  I was thinking about this the other day, but along a slightly different path. I realised there is no need to use web technology to provide native experiences anymore. Bundling a web browser was always a way to ship native apps to multiple platforms with minimal effort, but these days prompting up an actual native client for each platform is already accessible even to small shops! That's probably one of the biggest sources of software slowness, and we can just stop using it now, with almost no trade-off. Neat!
• nicekiwi 1mo ago
  [dead]
• nicekiwi 1mo ago
  [dead]
• bcjones524 1mo ago
  [dead]
• riazrizvi 1mo ago
  Not paying for premium? That's still a good reason. Even solo SaaS builders have to pay the rent.
• nogbit 1mo ago
  I had an Odin code base with raylib doing cpu bound stuff. On Catchy OS it tanked my frame rate from 120 to 90 fps (intentionally, seeing what I can get away with). Same build, on Windows 11, 40fps. the OS makes a huge baseline difference
• neo1 1mo ago
  Just an aside. mawk 2.0 (high performance awk) has been out for about a decade. It's about 2x the performance of its predecessor mawk 1.3.4, and 4x performance of GNU awk. Practically no distro uses it, because the author Mike Brennan is not the "I maintain this code in perpetuity" guy and the mawk maintainer Thomas E. Dickey doesn't care move on from from 1.3.4. The point is: Code needs to be maintained if it is to be relied on. I haven't heard good things about LLM's on that front.
• chvid 1mo ago
  ChatGPT MacOSX is the only software that regularly crashes on my machine when its memory consumption for no apparent reason spins up towards 50 GB. And that software is build by some of the highest paid software engineers on the planet with full access to all the LLM compute in the world.
  • blfr 1mo ago
    Yes, but it's also built by people who would rather tinker with AI than build MacOS apps. Intrinsic motivation is very hard to beat, especially in subtler areas like good UX or performant software.
    • chvid 1mo ago
      I think the software out of the big AI labs: OpenAI's ChatGPT MacOSX app, Anthropic Claude Code - is a sign of the future to come. Big, feature rich, built in quick iterations - but also, in particular if you look under the hood, of extremely poor quality if measured by traditional software engineering standards (code structure as exemplified by the leaked Claude Code source code, resource usage, "buggyness" etc.).
    • aureate 1mo ago
      OpenAI has 4,500 employees and a post-money valuation of $852 billion at its last funding round. You'd think they could get someone who specialises in writing MacOS apps to write their MacOS app.
      • chvid 1mo ago
        No. They want the AI to do it.
        • cpursley 1mo ago
          So have the AI build a hybrid Crux, Windows and web app with shared Rust base.
        • oblio 1mo ago
• bdhdhduuyd 1mo ago
  For me the comparison has always been 3DsMax vs Blender. Same kind of software, same kind of features, but Blender is so much faster. Architectural decisions have always been important.
  • moffkalast 1mo ago
    Ha, I'm always struggling with UI performance in Blender. Undo takes ages and freezes up everything, modifiers start lagging mouse movement as soon as you have more than a handful of polygons. I shudder to imagine what Max must be like. Though I must admit you can have an absolute shit ton of ridiculously complex objects in a scene, and it will run smoothly if none of them is in edit mode which is at least fairly impressive.
  • MaxL93 1mo ago
    You could compare it to Windows vs. Linux in a sense. 3ds Max has decades of legacy plugin/SDK compatibility baggage, lots of commercial and contractual obligations with business/enterprise customers... and Blender has none of those things weighing it down.
    • bdhdhduuyd 1mo ago
      Well, I have been using 3DsMax and Blender from the early versions and it's always been the case that Blender is way faster. Legacy baggage has nothing to do with it, in my opinion.
  • inigyou 1mo ago
    Fun blender fact: every .blend file contains a serialisation of the complete data model of the blender version that wrote it. That's why they have a minimum file size of about 280kB.
• troupo 1mo ago
  > There's no reason for software to be slow anymore There has never been. We are running supercomputers. And somehow every app is a dog-slow barely moving monstrosity incapable of showing a page of text without stuttering.
• jmalicki 1mo ago
  Dan Luu might benefit from having an LLM optimize his website for readability.
• fschuett 1mo ago
  The software model has to however be easy for agents to debug in a loop, then it works very well. I recently got Fable to take a desktop app (AzWriter[1] - screenshot Mac: https://imgur.com/31DBG04 https://imgur.com/31DBG04 + Linux https://imgur.com/1IavBvS https://imgur.com/1IavBvS) from about 150 Mb -> 80 - 90 Mb on a reasonably complex UI (around 40 pages of text, paginated, etc.), even beating KWrite (160Mb even on KDE, even though KWrite doesn't do pagination or complex text layout, was a surprise to me). What was important for this was the fact that I can run JSON-defined e2e tests[2], also good to find frame-based leaks, stale-ID problems and general "program shows its using lots of memory in the task manager" (task managers are wildly inaccurate for this, as I found out). So, I can just tell it "okay, loop this e2e.json test over and over again, use heaptrack, samply, find out why and exactly where it's slow, memory-hungry - find the section in the codebase, figure out a solution" and then let it run overnight. The biggest difficulty here is that many perf tools are still written for humans and that things like "how much memory are we using" is a wildly complex topic (lots of problems actually getting the correct number without over-allocation, memory allocator slack, OS-level page size, memory fragmentation, etc.). But Fable was able to track down things like "LCD font hinting causes 90k allocations that are unnecessary", etc. etc. - which then also improve frame time, usually. Memory optimization + better perf pretty much go hand in hand (less allocations = more perf). I could track them down manually probably, but it would take way more time. Having some basic understanding of data-oriented design, cache locality, memory tiering (L1/L2/L3/main RAM), does massively help with architecture decisions (e.g. Azul can use a single buffer for the entire DOM node list, in difference to normal browsers which do the more "object based" allocation model, which massively helped page breaking performance on html-to-pdf use cases[3]). Pure-functional style also helps (f(State) -> UI) because then it gets very easy to drill down exactly where things are slow and where caches are needed. [1] https://azul.rs/ui/release/0.2.0#demos https://azul.rs/ui/release/0.2.0#demos [2] https://github.com/fschutt/azul/blob/master/e2e/css-anim-perf-transition.json https://github.com/fschutt/azul/blob/master/e2e/css-anim-per... [3] https://github.com/fschutt/azul/blob/master/layout/benches/fast_dom_bench.rs https://github.com/fschutt/azul/blob/master/layout/benches/f... Note: UI Toolkit is still very WIP, docs + code are still slop, etc. - working on it. But I just wanted to add this.
  • exsol 1mo ago
• yayitswei 1mo ago
  The linked article is such a gem: You can choose how many bugs you want now https://nolanlawson.com/2026/08/16/you-can-just-choose-how-many-bugs-you-want-now/ https://nolanlawson.com/2026/08/16/you-can-just-choose-how-m... Love the concept of agents adding epicycles to fix bugs. It maps closely to my experience.
• anal_reactor 1mo ago
  Software speed is actually a binary thing. If it's as fast as the user then it's good. If it's not then it's bad. Think of it like a car - in theory different cars have different accelerations and vmaxes, but in practice if you can reach max allowed speed in your country (except Germany) and overtake all other cars you want to overtake, then you're happy; if you cannot then you're not. Here in hackernews we have a bubble of people who are very smart so they process information at high speed in general, and have lots of experience with computers, so they process computer-related information with extra speed. We're like race drivers, squeezing every single bit of performance from the car, while majority of use cases for a car is being stuck in traffic on your way to work. Those people simply don't care about performance above 150km/h because they'll never reach such speeds so putting expensive, high-performance engines is a waste of resources. The point I'm trying to make is that if software is fast enough for average user, and most users are fucking slow, there's no business need to further optimize it. You might keep arguing "but but but back in my days apps were instant and now they suck" but users simply do not care. This is why companies put shitty, time-wasting animations even if nothing is being done in the background.
• ozim 1mo ago
  Yes I do understand what author wrote as I read the whole thing, but I argue that title is not universally true. Like we have OLAP and OLTP, there are still batch jobs that need to happen before you can see your dashboard, we have multiple users using the same resources, there are still DB Locks when writing needed, there are "first load" issues — heck now we have to compete for resources with even more bots than ever. Transferring 10GB or 1TB of data still not going to be instant laws of physics still apply.
• rbehrends 1mo ago
  I think this oversimplifies the problem of dealing with performance issues. In my experience, there are three aspects that contribute to the software engineering cost of performance optimizations: 1. Identifying the cause of poor performance. 2. Implementation. 3. Architectural impact (performance is a classic case of a cross-cutting concern) (I am specifically leaving out the case of realtime systems, hard or soft, where additional factors come into play.) But the article seems to focus entirely on the second aspect, while largely ignoring the other two. Most performance bugs are not difficult to fix [1, 2], but can sometimes be hard to identify. Implementation effort is not the driving limitation in those cases. Conversely, other performance improvements may affect the overall design, e.g. 27% of all bugs identified in [3]. Having an obvious, self-contained optimization target with a benchmark where algorithmic optimization within a module is also the key problem seems to be the exception, not the rule. Also, not all performance issues are created equal. Many have trivial cost. In contrast, some of the most challenging performance issues are the ones that affect the design and architecture of the system. After all, the hard part of software engineering is not writing a small, self-contained application. It's managing system complexity, while maintaining (in the words of Fred Brooks) conceptual integrity. Fixing performance issues is at least in this regard not fundamentally different from fixing other software defects. Unfortunately, this is an area that is also full of trade-offs, such as performance vs. architectural simplicity, or performance in one part of the system vs. performance in another part, all of which requires judgement. For example, you may need to bypass an abstraction boundary or reorganize abstraction boundaries to improve performance. Or you may have to special-case something while keeping duplicated code at a minimum and easy to maintain. This is not to say that agents cannot help here, too. In fact, agents can be very helpful at e.g. identifying bottlenecks that are not directly visible in a profiler or can be used quickly do comparative evaluations of the various options for an architectural change. But solving these issues is not, like with the regex example in the article, about hillclimbing towards better performance, but involves a combination of puzzle-solving and design skill, IMHO. And finally, even a self-contained algorithmic improvement may come with an increased maintenance burden, especially around edge cases and through increased code complexity. [1] Jin, Guoliang & Song, Linhai & Shi, Xiaoming & Scherpelz, Joel & Lu, Shan. (2012). Understanding and Detecting Real-World Performance Bugs. Sigplan Notices - SIGPLAN. 47. 10.1145/2345156.2254075. [2] Selakovic, Marija & Pradel, Michael. (2016). Performance issues and optimizations in JavaScript: an empirical study. 61-72. 10.1145/2884781.2884829. [3] Zhao, Yutong & Xiao, Lu & Bondi, André & Chen, Bihuan & Liu, Yang. (2023). A Large-Scale Empirical Study of Real-Life Performance Issues in Open Source Projects. IEEE Transactions on Software Engineering. 49. 924-946. 10.1109/TSE.2022.3167628.
• rambambram 1mo ago
  There's also no reason for body text spanning the whole width of my 24 inch display.
• unlimit 1mo ago
  With RAM becoming expensive, developers will have no choice but to make memory efficient software.
• dvh 1mo ago
  Slow software is solved problem. Just give all developers Celeron J3455.
• tomxor 1mo ago
  Funny they mention demoscene as an example. I've tried to get various LLMs to explain or modify my demos and they utterly fail. At the extreme end this style of coding requires you to hold all understanding of what is happening end to end in your head, this x-ray vision allows you to reason and think about fundamentals without getting held back by abstractions. LLMs operate in abstractions. "Reasoning" is bolted on.
• crabbone 1mo ago
  There are so many unwarranted ideas here... I stopped reading half-way because of it. Eg. JIT compilers are rare because they are difficult to write. JIT compilers come with tradeoffs, they aren't an absolute boon. JIT-compiled code isn't good for short-running scripts, for example. Even normally JIT-compiled languages try to special-case parts of the code that would not benefit from compilation and interpret them instead. Another huge downside of JIT-compiled code is debugging it. JIT compilation is better for languages that don't deal with memory allocation directly, and, in general, expose fewer low-level primitives to the language user. It would be a fool's errand to make a JIT-compiled C... I bet someone tried it, but, seriously... Another one: a solution to slow search is building an index... Boy do I have bad news for you... Even a beginner DBA knows that an index can be a curse or a blessing. There's no one size fits all solution to this. And the author continues to misrepresent similar problems only to make his solution make sense.
• tcp_handshaker 1mo ago
  Every post by the this person, beats the record for most unreadable, most difficult to parse, smallest font, mangled and aggregated paragraphs. Make it as harder as possible to communicate your message...I am not sure if this is supposed to pass for minimalism...but looks more lie readability hostile snobbery. Good content does not excuse contempt for the person trying to read it. If your argument is worth attention, presenting it legibly is basic respect for the reader....
• kotaKat 1mo ago
  All we had to do was stop approving requests for developers to have 64GB of ram as a daily default. They could have worked in 8GB of RAM but chose not to, and now the rest of us suffer as a result because we couldn’t afford $5000 dev laptops as daily drivers.
• Havoc 1mo ago
  >you can choose how many bugs you want now, You are a rust expert. Make only 5 mistakes. :) Interesting quote though - I guess one does get to decide how much testing/debugging effort one wants now
• dkersten 1mo ago
  > Completely agree with your closing point. Dynamic custom software, fitted to a particular workload rather than a class of workloads, seems like a very likely outcome. I disagree with the premise that this is the desired outcome. If every piece of software is bespoke and everyone’s instance of it works slightly differently, then it’s impossible to get support or a shared knowledge of how it works. There’s no “just share the excel file”, there’s no “press the this button on the left”, there’s no “oh I use program X to solve Y” (instead you have to know what you need so the custom software can solve it, but my time in startups taught me that most users don’t know what they want or need).
• an0malous 1mo ago
  Eppur si muove
• rumisid 1mo ago
  Good read. I liked the point that even small performance improvements can be useful if they don’t take much time to find and test. But measuring the actual impact is still important.
• albatross79 1mo ago
  Sure there is. Nobody cares about quality, mvp and get to market first is what counts. AI means there is more reason for software to be slow, because it creates code more quickly and with poorer quality.
• formvoltron 1mo ago
  No reason web pages need to be ugly anymore.
• dofm 1mo ago
  Then there was no reason it took almost a year for Anthropic to find a workaround for a bit of screen flickering, right?
  • inigyou 1mo ago
    It's because they did it with ai
• PunchyHamster 1mo ago
  There never was. We had software that felt snappy on 90's hardware
  • inigyou 1mo ago
    It's all about machine thinking. E.g. when user scrolls, copy the pixels, don't redraw the whole page.
• softwaredoug 1mo ago
  The problem is that there’s a tradeoff between MANY objectives, not just performance You want code that’s fast, correct, stable, memory efficient, secure, usable, and more The reason code might be slow is about product tradeoffs. It’s certainly easy to have an LLM optimize performance only, but what do you sacrifice? Is that an acceptable tradeoff? Maybe slow code is a good idea if it’s the only way to get correct and secure code?
  • AlotOfReading 1mo ago
    I've almost never seen the trade-offs you're describing cause the slowness being discussed. Take slack for example. It's not fast, it's not correct, it's not stable, it's not memory efficient, and it's not particularly secure. There's a reasonable argument that it's usable, but that doesn't seem to have much to do with tradeoffs in their technology choices.
• steveBK123 1mo ago
  No there's a simple reasons actually: we have surrendered entirely to web based apps & the resulting ad bloat. You used to buy a computer, install an OS, buy apps and run them. Neither the OS nor the apps didn't suddenly degraded themselves with "free update" that were developed targeting newer & newer machines. You bought a new computer when new software you wanted to buy wouldn't run fast enough on it, OR the computer died. Nowadays, you buy a new computer when the same software you've been running for years or the OS itself that demands to be updated "free" makes your machine intolerably slow. Funny how that all worked out.
  • zahlman 1mo ago
    > Nowadays, you buy a new computer when the same software you've been running for years or the OS itself that demands to be updated "free" makes your machine intolerably slow. This is, in my experience, not a thing on Linux.
    • jambalaya8 1mo ago
      Sort of a thing on linux (and bsd) but not as often. An example is the mostly end of 32-bit computing, since 64-bit computing requires far more resources/RAM (arguably, some of that can be ameliorated with swapping, but it is wayyy less good). Or the way so many people were on netbooks and the growing monolithic kernel kind of made the default gig or two of RAM less and less doable (I guess non-consumer-modifiable tablets and mostly soldered and increasingly locked down chromebooks took over most of that market, but it feels like people just take storage space, memory management, and hardware for granted, now).
      • zahlman 1mo ago
        I mean, 64-bit computing at most doubles memory requirements, and there have been many other things motivating a doubling since the days of 32-bit computing. (And even more so since the days of 16-bit computing. For example: high-resolution, full colour monitors.)
        • 1mo ago
• voidhorse 1mo ago
  There was never any reason for it to be slow in the first place, yet here we are. In my view, we have slow software not because knowledge of optimization comes at a premium, in fact, most compilers do well enough at optimization that you can rely on them for at least acceptable levels of performance, assuming you choose effective algorithms for the task. Software is slow because other incentives are stronger than performance, and people more often make sets of technical choices that produce slowness (for example, opting for ease of development and portability over performance (see electron)). I don't think LLMs are going to change this. They won't change what companies and individuals value. Yes, they can enable those interested in performance to write even more performant software, more easily, but they won't convince the people who aren't prioritizing performance in the first place to prioritize performance. This ship sailed a long time ago. Performance was prioritized when it was necessary due to resource limitations. As soon as those lifted, performance was deprioritized in favor of other properties. I doubt the balance will really be restored until limitations re-emerge or consumers put pressure on companies around performance. Unfortunately, the past few years have shown that the latter is unlikely to work.
• gcanyon 1mo ago
  I'm a product manager. We work with Claude Code all the time, so I'm in Terminal pretty regularly. One of the developers insisted that I need to use his flavor of shell. He set it up to load automatically whenever I run Terminal, and now once the terminal window opens it takes another five seconds to get to the command line -- WTF?!
• joss82 1mo ago
  That’s the exact opposite impression of my recent user experiences of software: slower than ever. Contrary to what initiatives like the tigerbeetle team is doing with tigerstyle, or the 10 nasa coding rules, code created by llms tends to be verbose and slow.
• p0w3n3d 1mo ago
  Lol got my mac M5 128GB I'll import a JS framework for multiplying numbers Careless coding has been introduced by people saying "programmer's pension is more than double the RAM" but it is no longer the case. The windows UI could occupy 30MB at most. But they chose differently
• VCFundedGenYer 1mo ago
  The peak of fast software was definitely Windows XP, Windows 7, and OS X Snow Leopard. I don't see us returning to that glorious era. Recently I was frustrated by Windows 11's seeming inability to open a context menu with acceptable speed - right click an item in the taskbar and there is nearly a 1000ms delay before the menu appears. That is unacceptable. When I need to run old software, I now try to the "minimum viable runner" OS - start with an XP VM and slowly move upwards if it doesn't work. Obviously I'll lock it down from internet access/etc., but it really shows that modern OSes really don't have a grip on performance.
  • 5w6u56uw 1mo ago
    The peak of fast software is right now within the open source ecosystem.
  • mxuribe 1mo ago
    As much as i dislike Windows, i agree that the versions of the OS from that era were really fast (except for maybe Vista)!! As far as OS X, I had used OS X back around ~2007 - 2010, but can't recall what versions it was...and it performed fine back then too. I've been on one or another linux distro since around 2003 or maybe 2004, and have been running linux as my primary driver for laptops and desktops since maybe 2010 or so(right after i uncoincidentally abandoned OS X). While any issues that linux runs into tend to mostly related to proprietary drives, the majority of the time, things run fast...just like Windows did of that older, golden period of performance - and many times much better! I don't say this to sway anyone to move over/start using linux...and, in fact, linux is still far from perfect! Rather, its to show that there is joy in computing that still exists somewhere in the world. I have found it in linux, but i'm sure others have found it elsewhere as well.
    • titzer 1mo ago
      I dunno, Ubuntu got bloated. I tried to put 24 on an old Chromebook at it was atrocious. Going back to MX Linux made the UI relatively snappy.
      • 1mo ago
• mococa 1mo ago
  I see N+1 everywhere
• qsera 1mo ago
  Yes, Seriously, where is the native versions of LLM created slack, vscode and other memory sucking Electron apps. No one should need Electron now as well..
  • throwaway270925 1mo ago
    > where is the native versions of ... vscode Those at least already exist, without the need for any LLM: Sublime Text, BBEdit, Notepad++
• maxlin 1mo ago
  It could very well be argued that a move towards more optimized, yet still human-readable languages is appropriate. In a _very_ generic sense, LLM's can pick up the slack of those languages being harder to write, AND hard to debug. There is less of a need for super convenient, yet bloated languages now. For software that matters, and burns the most joules in the world, I hope we can also spend a few more tokens instead of doing it in interpreted python just because it's a bit easier for the LLM.
• Gormo 1mo ago
  I was having this exact thought after I overheard a conversation on a train, where two developers were discussing the quality of TypeScript being generated by Claude Code, and how they were getting closer and closer to having all of the architectural requirements, test cases, etc. in place to be able to one-shot correct and functional TypeScript. But if you're going to be relying on the LLM to do all the final-stage implementation work, and you've already got all the guardrails in place to ensure that the final output is performant, secure, correct, etc., then why would you still target TypeScript, which is entirely a kludge to shoehorn type safety into JS for the benefit of human programmers? But then why target JS, if it's just going to sit on top of a complex runtime like Node? Why not just target the language the runtime interpreter itself is written in, and just output clean C? But then C needs to be compiled down to assembly anyway, so why not skip that step and just output assembly? LLMs still have a lot of pitfalls and risk factors, and will always need human oversight, but in this case, what's on the horizon is something that can eventually eliminate all the intermediary bloat that only exists to optimize the development process when human programmers are doing all the grunt work. Eventually, we might be able to do away with the tradeoff between development velocity and runtime performance.
  • khuey 1mo ago
    One obvious reason to have an LLM output a high level language even if you are never going to read the code is because it will require fewer output tokens and therefore be cheaper.
    • senderista 1mo ago
      If LLM-generated code continues the human pattern of having roughly the same rate of bugs/LOC regardless of language, then I also expect LLM-generated code in high-level languages to be less buggy.
      • Gormo 1mo ago
        But why would we expect LLMs to continue that pattern over time?
    • 1mo ago
• stevetron 1mo ago
  If there's no reason for software to be slow anymore, then why, when I click on any item in my Windows 11 computer, does it take 30 secords for something to acknowledge I clicked? With a Ryzen 5 CPU boasting quite a few cores, an Nvidia gpu board, and 64GB of DRAM, why does it take so long?
  • system2 1mo ago
    I suspect MS Defender and other libraries loading, such as .NET.
• chrisjj 1mo ago
  Someone please tell me why a modern portable digital music player takes at least 10x as long to start up than its equivalent of 25 years ago.
• toephu2 1mo ago
  This part stood out to me: "Jamie Brandon got an offer from Anthropic and you probably can't afford him unless you're OpenAI" Interesting.. so how much do you think his package was worth?
• letmehelpyou 1mo ago
  [dead]