I can only hope what people will decide make trouble about is also what I consider necessary. If we could all agreed what was necessary to make trouble about there wouldn't be nearly as much to be making trouble over. It's a very double edged sword which does not necessarily do a very good job at bringing any more clarity of what the moral path was to the country.
I really need to get pill-pilled so I can keep up with what people are saying these days. From Urban Dictionary:
> 1: being aware of a difficult situation or position and having a fighting "can do" attitude and not giving up, plus accomplishing said thing(s) within the difficult situation. 2: being optimistic, not merely through gut feelings but via having thought about a situation enough to understand how to get through it successfully
> Tom: How'd you get to the top of this business in just a few months of work?
> Jim: Working hard, working correctly, and taking the white pill.
Somehow they did use this as part of their approach to get to 0 regressions across 65k tests + no performance regressions though + identical output for AST and bytecode though. How much manual review was part of the hundreds of rounds of prompt steering is not stated, but I don't think it's possible to say it couldn't find any deep logical errors along the way and still achieve those results.
The part that concerns me is whether this part will actually come in time or not:
> The Rust code intentionally mimics things like the C++ register allocation patterns so that the two compilers produce identical bytecode. Correctness is a close second. We know the result isn’t idiomatic Rust, and there’s a lot that can be simplified once we’re comfortable retiring the C++ pipeline. That cleanup will come in time.
Of course, it wouldn't be the first time Andreas delivered more than I expected :).
That’s convincing and impressive, but I wouldn’t say it proves it can spot deep errors. If it’s incredible at porting files and comparing against the source of truth then finding complicated issues isn’t being tested imo.
Are the eyes really "no better" in this scenario? From the above article it seems we tuned the behavior to the eye specifically (but not necessarily image sensors):
> Moving to a longer wavelength that does not penetrate the human eye allows new lidars to fire more powerful pulses and stretch their range beyond 200 meters, far enough for stopping faster cars. Now a claim of lidar damage to the charge-coupled-device (CCD) sensor on a photographer's electronic camera has raised concern that new eye-safe long-wavelength lidars might endanger electronic eyes.
> Producers of laser light shows are well aware that laser beams can damage electronic eyes. “Camera sensors are, in general, more susceptible to damage than the human eye,” warns the International Laser Display Association
"doesn't penetrate the human eye" seems a bit hand wavy, but I take it to mean "these length pulses in this wavelength are tuned to have the power not be enough to damage the eye". Camera lenses may not have the same level of IR filtering/gathering area or, if they do, there is nothing implying the image sensor has the exact same tolerances as the inside of the eye. From the same:
> Sensor vulnerability to infrared damage would depend on the design of the infrared filters
A heater usually damages the eyes through drying out/heating up the outside layer with constant high intensity, not by causing damage to the retina (post filtering). https://hps.org/publicinformation/ate/q12691/
> Furthermore, since the eye blocks the IRR, the eye begins to overheat leading to eye damage and possible blindness. Because of this, you should not look at the heater for an extended period of time.
Enough intensity of any wavelength is enough to damage any camera or eye of course, but the scenario here seems to be built around that question for the eye. Similarly, I've heard of Waymo's causing 6 mph accidents but no reports of eye damage from any car LiDAR. Despite that, in the above YouTube clip Marques Brownlee actively shows his camera being clearly damaged as its moved around.
If a Walmart has ~100 people in it and wants to get rid of 4 shoplifters but really sucks at selecting them well then the likely result is 4 normal people are very upset while all of the shoplifters are still there.
In the same scenario, even if Walmart is right about who they ejected 75% of the time then they still have ~1 shoplifter remaining and ~1 very upset person.
Even in an ideal world where Walmart is right about ejection 100% of the time it doesn't mean they start receiving 0 new shoplifters either, it just means the number of people wrongly made upset is 0.
Discord's problem (on both ends) lies in lack of depth in investigating bans. It takes resources to review when someone shouldn't be banned and it takes resources to make sure you ban everybody. Putting too low of resources into banning just means that both sides of the scale manage to get tipped in the wring direction at the same time.
The use of "Free" in the title is probably too much of a distraction from the content (even though the opening starts with an actual cost). The point of the article does not actually revolve about LLM code generation being $0 but that's what most of the responses will be about because of the title.
The article already concludes coding agents have uses in areas they already do well. What specifically can be continued leading you to think should instead not be used?
The claim that somehow "code is free now" is struck low by anthropic choosing electron is silly and deserves ridicule.
I guess I don't understand how people don't see something like 20k + an engineer-month producing CCC as the actual flare being shot into the night that it is. Enough to make this penny ante shit about "hurr hurr they could've written a native app" asinine.
They took a solid crack at GCC, one of the most complex things *made by man* armed with a bunch of compute, some engineers guiding a swarm, and some engineers writing tests. Does it fail at key parts? Yes. It is a MIRACLE and a WARNING that it exists at all? YES. Do you know what you would have with an engineer-month and 20k in compute trying to write GCC from scratch in 2 weeks in 2024? A whole heck of a lot less than they got.
This notion that everything is the same just didn't make contact on 2025, and we're in 2026 now. All of software is already changing and HN is full of wanking about all the wrong stuff.
The title is indeed silly and a poor choice but it's not the argument actually made in the article.
The title doesn't even seem to be intended as a shot in the night, despite that being how most of the HN took it. I.e. the author isn't saying "don't use agents because Claude Code is written in Electron" they are genuinely looking at why one would still have their agents write an Electron app over native when using coding agents.
the central argument to the piece is still fundamentally silly. What truly do we know about the organization that produced the Claude desktop app, by virtue of the fact that they built it in electron?
Really truly what do we know about them based on that decision? I submit the answer is basically nothing.
Instead, we’re sort of coasting on priors and vibes about “native” tool kits being better. And that’s just catnip for people on the Internet who want to talk shit about code and don’t know what the fuck they’re talking about.
If native is a stand in for better in your mind and you conclude that they made a choice that was worse because it’s not native then therefore you can conclude that they are bad somehow. But the connective tissue there is not whatever they’re designing choice is (and of course we have no vision into the actual choices). It’s the un-investigated prior. That native is good and cross platform is bad. That’s really what people are arguing in this thread.
And the only reason we don’t see that is completely fucking ridiculous is because we are also interested in talking about how AI is bad.
So everyone gets to have two bites of the cookie and nobody gets to defend an actual argument. It’s so silly that I don’t think that we can claim that the piece is actually much more moderate and subtle than everyone is reading it to be. Because that’s kind of a dastardly position too. It allows the main argument to be advanced, and whenever it is questioned, one can retreat to claims of nuance.
I think it's silly we have to judge what the article is saying by how it's argued in the HN comments, especially on something divisive where many comments react to the conclusions they made when they saw the title.
The article doesn't go as far as saying Electron is bad or judge Anthropic based on their use of it. It says Electron has downsides which are dramatically outweighed by the upsides and then shows that calculus remains true (i.e. the benefits of Electron still outweigh any of the potential downsides) even when using LLMs as coding agents. The article is not setting out to ridicule anything, it's investigating why Electron is still a good choice in the coding agent use case by looking at one such app (the Claude desktop app) written very close to home for coding agents as an example.
About the only thing the article can be said to ridicule at all is that the Claude app is slow and buggy (which is accurate IMO) but it's never saying that to imply it's impossible to solve that because it's an Electron app or that it means one should not use coding agents. The rest of the article really stands to state quite the opposite.
As the article concludes, it is a pro-Electron usage pro-coding-agent piece. I.e. that the Claude desktop app is written in Electron is NOT evidence either Claude or Electron must be bad:
> For now, Electron still makes sense. Coding agents are amazing. But the last mile of dev and the support surface area remains a real concern.
That last mile is where the author places the problems, and they had placed them there regardless whether one uses Electron or coding agents, so it's hard to take it as a hit piece for those two things.
I mean the article is pretty short. And what it implies presents itself in the subtitle! It opens with a "fact" (a link to the author's own tweet) which says:
"The state of coding agents can be summed up by this anecdote:
Claude spent $20k on an agent swarm implementing (kinda) a C-compiler in Rust, but desktop Claude is an Electron app."
We haven't made it 100 words in and we already have the core claim. In case we missed it, the author puts it in an inset later:
>So why are we still using Electron and not embracing the agent-powered, spec driven development future?
We get to the end where the author says:
"For now, Electron still makes sense. Coding agents are amazing. But the last mile of dev and the support surface area remains a real concern."
That's both true and and misleading. It's misleading because we can all agree with this sober-minded concluding statement and forget it's just based on "Electron bad, native good". The real logical sequence the author needs us to follow is:
Anthropic said code is free now. > Native code is harder than that for a cross platform runtime > Anthropic releases an app on a cross-platform runtime > code must not be free.
That is only true iff there's absolutely no other design tradeoff! Did they pick electron because robots are bad at the last mile? Maybe. It's pretty dubious, given the MANY MANY other people who made electron apps before AI could code. It's also not at all clear "native good, electron bad" is true at all. It reminds me STRONGLY of "jQuery bad / native good" which was also groundless.
I think we see that opening from very different perspectives. You see it as "this kind of statement must only mean they wish to attack these things with it, as that's the only conclusion I would make from the statement" whereas I see it as "this statement grabs the reader's attention to make them read through on why the author likely sees it differently than the reader would assume one normally expect from that". It is relatively short. I don't see that as a crime though, particularly for the latter style posting you don't want to lose most of the audience before the end.
I.e. yes, coding agents can't make everyone happy and do 100% of everything - but by the end the opposite of the expected point from that is reasoned. It may not be exhaustive, but that does not automatically mean the sole point is reductionist. It only takes one counterexample of reasoning to show a point invalid, so if you don't assume the goal is to make Electron and Claude actually sound bad then these points are not really problematic.
As someone who sees themselves more towards the center of the AI debate I found the article surprisingly refreshing in not trying to argue absolutes about extremes. Others who sit more towards the extremes probably see it as an attack piece (regardless of which extreme) just because it doesn't go as far as they'd like in each regard.
You can't conclude anything reliably from their choice of electron over native apps. You can't. You can ASSERT things like the author does, like "The state of coding agents can be summed up by this fact: Claude spent $20k on an agent swarm implementing (kinda) a C-compiler in Rust, but desktop Claude is an Electron app." That's a fine assertion. It's just not a fact or knowledge about any kind of design decision.
The whole argument revolves around knowing that electron is a compromise because one could just make multiple native apps without asking if "make multiple native apps" serves a design need the developers had at all! If the developers (like many others who use electron) did not declare "we want to make native apps" or have a need that caused that to become a desire, then inferring that using electron is a compromise at all is groundless. It may never have been a compromise to begin with!
The parts you keep quoting are the rhetorical questions in the opening, not the actual arguments. The article is written for those who might assume these things mean something about Electron or Claude, not to argue those assumptions are actually true the whole way through. E.g. in an article starting:
"We have cheap elevators, why aren't all floor connections using them?
The state of elevators can be summed up by this fact: The OTIS Elevator Company Factory Building cost $x million to build, but it still has stairs"
The only thing this section asserts is "stairs seem to still be chosen". It's not actually asserting anything else yet, it's grabbing the attention of those who commonly assume this must mean a lot of things. It sounds exactly like something someone who would want to say Elevators and OTIS are useless bad crap would start with, but intentionally stops short of that conclusion from these to instead take things in a different direction which is still compatible with this information.
The assertions on Electron actually start later on here, and do not source from the design decisions of the Claude desktop app:
> There are downsides though. Electron apps are bloated; each runs its own Chromium engine. The minimum app size is usually a couple hundred megabytes. They are often laggy or unresponsive. They don’t integrate well with OS features. (These last two issues can be addressed by smart development and OS-specific code, but they rarely are.
These are not sourced from the design decisions of Anthropic. The first is an assertion of fact of what Electron is, a bundled instance which runs a full browser engine resulting in a large minimum app size. The next two assertions are actually not assigned to Electron itself, rather development effort. The only poorly sourced assertion here is that such apps are rarely well optimized, but if you take issue with that it does not actually impact the rest of what the article talks about.
The article then spends some time talking about why Electron is actually a common choice despite this, which eventually leads to the actual assertions about Electron's usage in the Claude app:
> But we’re still leaning on Electron. Even Anthropic, one of the leaders in AI coding tools, who keeps publishing flashy agentic coding achievements, still uses Electron in the Claude desktop app. And it’s slow, buggy, and bloated app.
There are 3 assertions here.
1. Anthropic has shown all sorts of flashy things with AI coding tools
2. The app is still using Electron
3. The app is slow, buggy, and bloated.
These assertions are not interdependent, they are just observations of the app. The article is still not arguing Electron can only be slow/buggy (though it has previously asserted it must be bloated by nature) nor is the app asserting why Anthropic has made these design choices yet. It is still following the train of thought one might be biased to from the original thought but carrying it further to perhaps unexpected conclusions.
The question in the reader's mind the article seeks to next pre-emptively answer is now stated: "So why are we still using Electron and not embracing the agent-powered, spec driven development future?". Most likely the reader has "make it a native app" as the first path, but the article already laid out 2/3 of these things can be solved with a smartly written Electron app. In either case, the article is not asserting why the Claude desktop team chose/chooses a particular design choice, it's seeking to answer why having great coding agents isn't necessarily a free answer to slowness, bugginess, and bloat in a cross platform app.
This is where the article finally makes its core argument:
> For one thing, coding agents are really good at the first 90% of dev. But that last bit – nailing down all the edge cases and continuing support once it meets the real world – remains hard, tedious, and requires plenty of agent hand-holding.
Using quotes from Anthropics implementation of the C compiler to back up this claim and then continue discussing how the benefits of a common approach over an optimised approach still exists outside of the raw code writing portion of the problem. At this point the article is still avoiding that the Claude desktop team must want a native app as a design goal, only speaking to why coding agents aren't the cure-all for the particular problem set (regardless of approach).
This is why the article concludes:
> For now, Electron still makes sense. Coding agents are amazing. But the last mile of dev and the support surface area remains a real concern.
Rather than:
> For now, it's clear coding agents must suck because Anthropic hasn't used them to come up with a more efficient alternative to the obviously poor choice of Electron or rewrite the app as separate native apps - which must obviously be their goal because coding agents are supposed to be able to write code
The difference between 1900 and 2000 seems to largely be the voice/intended audience changing rather than the language.
I.e. the 2000s one is a casual travel blog style intended normally intended for any random quick reader and the 1900s one is more a mix of academic sounding/formal conversation intended for longer content. If you assume a more casual voice in the 1900s one and a more formal voice in the 2000s one I bet they'd even almost seem to be placed backwards chronologically.
just noted that in reply to my post but repeat here:
yeah I was wrong, I happened to look back at Maiſter and my bad eyesight and the resolution made it look like the long s had a crossbar from the t next to it in the default font.
on edit: this was probably where my problem generally was, in lest and Maister and anything where the long s is next to a t it looks very like an f to me, although if I zoom to 170% then it is clear, however at that size it introduces its own reading problems; unfortunately my reading glasses are broken so I just struggled at a lower resolution.
reply