The kinds of large scale projects I like to make in SketchUp really began to feel constrained at a certain point. A modeler with SketchUp's incredible UI that can take full advantage of any computer's available graphics hardware to render large amounts of geometry more efficiently would be a wonderful thing.
I'm very possessive of my SketchUp models, and so the idea of storing them on any kind of cloud server I don't have control over is abhorrent to me. I was not happy to see Trimble putting so much effort into making a web-based modeler.
The vibecoded apps all rely on an army of users exploring the program and reporting all the bugs and edge cases. You don’t want to be doing that on your own.
It’s always more work than it looks. You can get to mostly usable tools quickly if your request isn’t too difficult, but every time I use them I run into another thing that needs to be fixed, changed, clarified, or cleaned up.
It’s fun at first, but over time you realize you’re spending more time building the tools than using the tools to build the thing you originally wanted to work on.
I think personal software is best for highly specific tools or for things you need to use repeatedly for a very long time.
For something like a SketchUp competitor, I wouldn’t want to try to maintain my own. The number of edge cases and features is bigger than you imagine up front, and the vibecoded version that might appear a few hours after your prompt is going to be very far from the version you want to use.
I think it comes down to where you want to spend your time and attention.
Need a 3D modeler? Use Claude or codex to build the 3D model first, then build the modeler around it as you iterate towards what you want to build
So many times I’ve had to spend hours learning a software, reading docs, doing tutorials, only to later be able to do a small basic idea of what I actually wanted to do in the first place
Now I can just build only the software I need, for the thing I need it for (or, ala REA, maybe either modify or reverse engineer some existing software, to better fit my workflows)
In that sense, it would also be cool to be able to drive KetchUp with an agent. I’m a big fan of what pen.dev has done (although now their tool is not free/open anymore)
Impressive how good that rust UI feels in a browser though. Even the text rendering is impressive. Maybe rust really is the future of cross platform web+mobile apps.
From the article itself:
> Disclosure: I ported GPUI’s current Linux renderer to wgpu2, I built the benchmark harness used below, and I work on zgui, a signal-based Rust framework that appears in the charts.
https://github.com/zortax/zgui
zgui just released version 0.1.0 last month, with a 3 month dev history. And it's their only version.
https://github.com/zed-industries/zed/tree/main/crates/gpui
https://crates.io/crates/gpui/versions
GPUI's last release was 0.2.2, 1 year ago.
Framework maturity is an unavoidable contributing factor when choosing where to port over your application.
Should that mean that they can only choose 10-year-old frameworks? No, but also they shouldn't be chasing 1-month-old projects.
There are minimums & maximums, and the minimum sits at "definitely not 1 month old projects with only 1 public release".
> What a write runs | Who finds the change
Good lord. If you are writing a thoughtful critique of something.. actually write it.
If you thought about this, write it yourself.
[0] https://finance.yahoo.com/technology/ai/articles/apple-cuts-...
[1] https://finance.yahoo.com/technology/ai/articles/accenture-j...
Giving people some constraints so they have to actually think about solving their problems properly rather than just throwing money (or tokens) at it is not a bad idea.
The "SaaS is dead" narrative is a bit overblown, but private equity needs to think twice before gouging folks these days.
They do have this "usage based pricing" where you pay them for each user, but then also for each project and customer, and then a percentage of your billings. It's completely absurd to be paying them a percentage when you receive payments by wire and all they're doing is emailing an invoice.
Anyhow caveat emptor. Looking at their website they do not show the actual pricing. They just say it's "starting from" $9/seat or $14/seat, but you only pay that if you don't use the software at all.
As far as I can tell, what Bending Spoons has figured out is that they can raise prices 8-10x, but only maybe 60-80% of their customers will cancel because it's a big hassle, and so the profits go up massively for a while. They will probably even retain a hard core of say 10% of their original userbase for some time.
It isn't about the money, the principle is gross. Thankfully Asana's core business is now a prompt. We are nearly done replacing it with a native, self hosted client. Will post about it once it is hardened through use. Cancelling our Asana subscription this week.
To SaaS providers (myself included) it has never been easier to leave your service due to mistreatment. Take note.
You can have those lower monthly fees if you pay a higher percentage of your billings.
The article acknowledged that.
> There’s also a “flex” plan which costs $12.65/mo… but that plan now skims an additional 2% on top of the usual ~3% card transaction fees.
The problems with the Harvest acquisition driving up prices has been discussed a lot among consultants and contractors. This isn’t one person reading their billing page wrong. This is happening to all of their customers.
It’s how the acquiring company operates: Acquire companies, increase billing, accept that most customers will leave but some will stay and make up for the losses.
It also means a platform's features are not duplicated so your app's behavior sticks out as having a different experience from everything else the user does making it frustrating.
That said, if you want see an app in WebGL/WASM where the browser is rendering everything there's https://earth.google.com as a high end example. It has most of the issues just mentioned as well as the fact that nothing is selectable by default. Want to copy a name so you can paste it into your search engine of choice. NO! Want to right click on a foreign name to find out how to pronounce it? NO! etc....
Bjarne’s opposition to contracts might have tipped the scale but there is definitely growing weariness (and wariness) about large half-baked features that are left as exercises to the implementors (looking at you modules).
Ignoring that historical context when analysing this vote seems like a mistake.
The vast, vast majority of software, and software developers, simply do not care about core affinity, NUMA, noisy neighbors, etc.
Even on systems or situations where this matters (massive number of cores and memory, multiple sockets, thousands of threads, etc.) the juice is rarely worth the squeeze.
Doubly so when you end up being I/O bound anyways.
Nearly every software developers wants their software to work across multiple deployment targets. Maybe you just target x86-64, and you don't care about the number of CPUs because you'll be upgrading your servers every couple of years.
No one wants to deal with difficult-to-reproduce issues related to scheduling in niche configurations. It's much more efficient for runtime or compiler engineers to solve these problems for us, leveraging the vast amount of resources of corporations to develop and test these features. Then you have a place your code can live happily ignorant of its runtime constraints.
And that, my friend, is the beauty of our industry.
It's basically everyone learning from everyone else on what works and what doesn't work.
I’m not blaming the author maybe this is their original idea and its edited by AI but I physically can’t keep reading it. AI blindness or something.
In the earlier days when they were slower and their code was worse so you had to review it, I’d watch the model code and just noodle away on guitar while it did its thing, interrupting it from time to time. Now they’re too fast for that to work, but still too slow for it not to be worth it to start a new task. It’s an awkward in-between stage.
If Anthropic made fast mode four or five times faster rather than just twice as fast, I’d probably shell out for it sometimes just to be able to single-task productively.
Every review I’ve ever done I’ve found overfitting and brittle solutions and things tacked on instead of integrated so I refuse to give up on code reviews, but those are my real bottleneck, and having three is so much worse than one because my context and understanding is diluted and a bit muddled.
I want to time how long it takes me to land code and I suspect going serial on one thing will be faster than going parallel on multiple things. Parallel feels faster but the code review takes longer.
Every time I find myself idling in front of a screen, I feel the need to find something else to do, a distraction to fill those 54s before the agent sends a notification that needs my attention. This isn't healthy, and it's not how the human brain works.
Long, uninterrupted sessions of deep concentration are what helped humans produce their best work so far.
> "The page is only a viewer — git is the record."
> "Then comes the part that matters most."
> "That closing is the whole trick."
Not sure how much I trust an article on fighting AI brain fry in which the author outsourced writing a handful of paragraphs to AI...I hope the irony is not lost on anyone else, lol
So I limit myself to at most 2 or 3 things at once, and if all of those are in long running sessions, well so be it, I know I'll be deep back in it soon.
But it's tempting to start "just one more session", especially something like getting it to better profile and improve performance. That feels super productive, but is often just to stop me feeling "idle".
https://x.com/jamesonhodge/status/2118733265372860826
https://x.com/klausbrave/status/2119372853502177323
https://x.com/CupOJoseph/status/2119260104641900595
Also is the name a Teto reference?
Being trans, of course voice affirmation training.
Then singing comes to mind, followed by language learning.
A solid visual demo like this would help give people more than "okay now more like the a in aunt"
Nowadays you would just "npm install drag-and-drop" but back then you often had to hand-roll solutions.
If anyone can dig up an ancient library on GitHub for drag-and-drop back in those days, I'd imagine it would be several thousand lines long, not to mention the absolute nightmare that testing something like this with a proper framework and accompanying testing library.
At my very first job, we had a weekly meeting to assign tickets and estimates.
Our non-technical PM wrote "drag-and-drop" on a whiteboard, and then my name.
"Gavin, how long do you think this will take?"
"All week. At least. Maybe longer?"
PM laughed, then realized I wasn't making a joke.
"What do you mean 'all week'? That's ridiculous, do I need to give this to someone else?"
"Well, you could, but I wouldn't count on you getting it any sooner."
Appalled, he exclaims: "It's just drag-and-drop!"
After 10-15 minutes of a room full of engineers trying to explain the difficulty, he gave up with an unhappy "Fine."
The phrase "it's just drag-and-drop" became an inside joke for the rest of my time there...
[0]: https://hazel.org/
Paper here: https://declarative-dragging.github.io/D2.pdf
IMO one of the remaining gaps of agentic coding is that it's hard for even multimodal LLMs to check interactive motion effects for correctness and "feel." Like, sure, they can take screenshots of a few snapshotted states, but in terms of how things react as underlying nodes move and (potentially) reflow. How do you QA the feel of moving your wrist rapidly in the context of nested zones?
The answer is that you avoid the need to: you have a (nearly-provably) correct foundation that ensures that behavior is predictable regardless of state, and just render accordingly.
The paper's approach is incredible here: simultaneous optimistic rendering of multiple possible states, and a composable algebra (a small combinator language) over how drop zones and distance are derived - allowing for an extremely high-level interface in practice. Everything feels snappy and right, and the code you write is about as minimal as you can get - though the paper notes that state management is somewhat complex. But this seems solvable!
Once this is ported to HTML, it'll become an incredible part of the modern dev toolkit. I'm very excited for what this means.
I am not sure how I feel about the curl | sh installation. This seems lile the kind of project which should become part of a Linux distro and thoroughly reviewed before it can be trusted unconditionally.
It also just added official support for atomic distros like Bazzite; it was previously kind of an annoying gap given the popularity of those distros.
There are 100 different ways that the CEO falling victim to an espionage plot could impact the business.
Oh no, not again, I just cheated on my wife with a chinese spy, it just "happened to me"
It's worse than that - his mistress was a spy. This carries additional concerns since it opens the possibility of blackmail or extortion.
Nvidia is doing an investigation of Jensen Huang being targeted in an intelligence operation; ie, an investigation of something that happened to him.
The title implies that Jensen Huang is the target of Nvidia's investigation.
Or as Charlie Munger put it: There are only three ways a smart person can go broke: Liquor, ladies, and leverage.“
Or was the plan just to publicly humiliate him in hopes he'd get replaced by someone less capable?
"Nvidia Board to Probe Spying Case After CEO Admits Infidelity"
https://www.bloomberg.com/news/articles/2026-11-08/nvidia-bo...
But you’re not generating Opus or Fable tokens.
And people buying subscription plans aren’t paying API rates.
I have a Claude subscription and I have hardware to run Qwen3.8-Flash-Next a full order of magnitude faster than the theoretical system you specced above.
In no way would I ever consider my local Qwen3.8-Flash-Next setup comparable to even a $20/month Claude subscription. It’s just not.
I do try to use it for bounded tasks from time to time, but using it for actual complicated work generates so many problems later that it’s not worth it.
Often I can have Opus produce a better result in 1/10th the tokens. The Qwen model often gets things wrong that require 10X as many tokens to debug or fix later. You cannot make comparisons like you’re trying to do.
That's $104/day of opus 5.5 tokens, or $265/day of fable 5.1 tokens.
If you were able to saturate usage of this system, you could pay it off in 3 days of fable time or 6 days of opus 5.5.
But ok those are more intelligent. Let's go with something that scores similar - sonnet 4.6. 5.2M tokens is $78/day and the system is paid off in 8 days.
I don't see how anyone justifies a claude subscription. Do you want to rent the tools you use to making a living from the people who are trying to automate away your job?
It explicitly says that Quantization-Aware Training is out of scope, may reveal different trends and has potential for extreme quantization. Heavily-quantized model releases today generally use QAT or something similar, so I don't think the paper can be universally applied to modern quants (e.g. [0]).
That said, I don't see any evidence that TFA does any of that so the paper's claims may be quite applicable there.
[0]: https://huggingface.co/vcruz305/DSV4.1-Flash-1017-SAGE-REXL3...
Also, I've been playing with speech models for the past 2 years, and for me anything below 8-bit is a huge drop in quality; so quantisation for LLMs and for other bespoke modality models, is not 1:1.
[1] "Reliability Scaling Laws for Quantized Large Language Models", TUM, https://arxiv.org/pdf/2607.10855
Reddit is flooded with these breathless headlines “xyz tokens/s on my light switch”. It’s always quantizations below 4 bits per weight. Mostly useless.
EDIT: I think it's 2 bit? If so, would be curious to see the quality of the output. Not great, I think.
> The web browser is very, very, very powerful software for applications, and the cost of accessing that power is going down seemingly every day.
It's wild how much easier it is to build things that harness web technology these days. I'm building features on top of three.js and offline storage and SSE and WebAudio and WebAssembly multiple times per week these days. I used to tinker with some of those maybe once or twice a year.
(Anthropic themselves acknowledges this; see the end of the post.)
We should stop using "solve" when we mean "releasing products to target". Nobody will ever solve this problem with LLMs as they are currently architected.
Enterprise sales are where the revenue for the $1T valuations comes from. If they were forced by competition to offer subscriptions to all those organizations, they'd blow up tomorrow.
You cannot have semi-unattended agents running on the same workstations that have access to client/trade/prop information and email client, and internet, and internal networks, it's too dangerous--a major leak is just one small mistake or prompt injection away. Banks are not stupid, they are getting it and shutting it down.
1) Claude Code is only being taken away from traders.
2) Only traders have permission to send orders to the market and book client trades.
3) Claude code would probably have been running as the trader, under their account with minimal review.
If you run a coding agent in that environment it's only a matter of time until it enters a bad order or books a bad trade, and once that happens it's only a matter of time before management decides to take this kind of action.
Goldman is definitely not doing this for cost reasons. They can afford the tokens.
Is just the first hit your dealer gives away for free. Treating that as the actual baseline cost for what they need in order to justify current AI valuations requires some truly fraudulent mathematics. Hell, even the current API rates are unsustainable -as-long-as- they need to keep investing into training the next model they will be serving 6 months from now.
The plan has always been to develop these models using borrowed money, get everyone's business process addicted to them, moat off access to alternatives (e.g. chinese / foreign open-weight models), via technical superiority -or- more likely regulatory shenanigans, THEN jack the prices up through the roof starting with direct enterprise customers buying API access but then obviously bubbling down into literally every product / service every human being on this planet purchases. Unfortunately, it's a garbage plan based on a multi-ton house of cards that is about to collapse on everyone.
Source: I've worked in and with many successful organizations, and worked at one place with proper internal processes, so I know what's possible
Anything above that requires an Enterprise plan, which is billed at API rates.
Also AIUI both claude[0] and chatgpt[1] offer HIPAA compliant BAA’s.
0: https://support.claude.com/en/articles/13296973-hipaa-ready-...
Gemini is swooping in because they offer flat consistent billing and handle overages through throttling access to higher models. For 90% of the non-engineering org the experience is near enough it makes no difference.
Banks have a ton of legal/compliance/reglatory/reputational concerns about application access/entitleements, data privacy, data licensing, granular data entitlements, data access (auditable).. approval chains (auditable), as well as actual financial risk.
Internal guidance updated in October restricts Anthropic's Claude Code and Microsoft's GitHub to the bank's engineers
There. Now only devs can use Claude Code. That makes sense.Has nothing to do with AI being bad. Good engineers have a mind for it. They tend to be more detailed oriented. Understands how parts connect. Understands the pros and cons of approaches. Can see when the AI does something stupid. Probably knows a better way if the AI veers off.
We don’t ask software engineers to file Goldman Sachs yearly company taxes using just AI right without any expertise right?
We don’t ask engineers to go out and do cold calls for sales right? Engineers don’t have the mind for that. They’d suck at it.
We don’t ask sales people to write programs right? Have you met a sales person? They’re the opposite of builders. They lie, take corners to close a deal. You can’t do that building a real production system.
As someone who has been on the receiving end of many of these tools, I feel 'improved' is doing some heavy lifting here.
Completely overhauled to be operationally viable, perhaps.
Thrown into the dark recesses of the backlog, more likely.
The context for people's reaction to this is that he has single-handedly caused the current spike in RAM prices.
fortunately one can just run debugger; to stop it early
For audiobooks, I seem to not have as much of a tendency to pause the audio and stop and think, and it’s harder to reread a passage, so it’s a more passive experience.
For online content, there’s not as much of an intention to fully engage with the material. It’s easy to skim or switch to something else.
Even worse: Facing AI writing, there's a strong suspicion that any concerns or counterpoints you bring won't be actually considered, but rather copypasted into an llm session.
When you are writing code manually, actually you are thinking about what you are doing, what you will build actually, what are your or users' real requirements, etc.
The problem with AI writing is that it makes people believe that writing is just writing and not a tool for thinking very deeply about the topic you are writing about. I am not completely opposed to AI assisted writing, but if I see AI writing, it’s telling me that the author tried to take a shortcut in their own thinking and it’s a good heuristic that the ideas will not be thought through enough to warrant my complete attention.
There is something about the complete free form nature of pen and paper that makes me think better, I bought a nice ipad/pencil a few years ago thinking that would replicate it but it didn't, it was closer but not close.
If it's something I want to keep I just take a photo but vast majority of notes are transient anyway.
When I get it on paper and everything feels right I start creating the codebase but I have to get it down first, feels like I remember it more after I save my thoughts to external paper storage.
If your app handles personal and sensitive user data, then you must ... Not sell personal and sensitive user data.
The rule also applies to third-party code. If you include third party code (for example, an SDK) in your app, you must ensure that the third party code used in your app, and that third party's practices with respect to user data from your app, are compliant with Google Play Developer Program policies... For example, you must ensure that your SDK providers do not sell personal and sensitive user data from your app.
https://support.google.com/googleplay/android-developer/answ...Isn't this abuse what we are supposed to be paying their 15% Play Store tax to stop?
Are parents going to be arrested for pictures of their kids in the bathtub? Or at least are they going to be blurred?
Anything with a UI is by definition made for the purpose of being used by a human. The use of Electron only makes sense from the perspective of preserving programmer man-hours, and it led to another generation of newer, faster computers dragged down to the speed of older, slower computers, and a wretched user experience.
Regardless: this is great news, I never thought Discord in particular would ever make a move like this.
Best example is vscode.
Are Electron apps more wasteful than native: sure. But I rather stand with Electron and that Windows, Mac and Linux is supported.
And more memory usage can slow down the whole system, because the system may need to swap and compress memory.
A well built web app will never be more performance than a well built native app. It's just inherent due to the JavaScript abstraction.
And keep in mind we're talking about a damn chat client, not some complex video editing or CAD app.
That was absolutely not the case at all. At least not on HN or twitter. It was for Chief Complaints for Atom. When VS Code first launched everyone was suggesting how much faster it was compared to Atom. And how a properly tuned Electron Apps could be fast. And Microsoft promised it will get even faster that makes everyone excited.
The only few of us who were complaining was how could everyone judge this to be fast when we have Sublime. And that was even before Sublime had GPU rendering.
I’ve worked in Qt apps on and off through my career.
I do not want Qt apps any more than I want Electron apps.
The solution is native apps using native platform tools, or one of the mature cross-platform toolkits.
Chrome had already solved the hard problem of "how do we support webcams on linux, windows, and mac" and you as the dev just needed to use the Javascript webcam api. ( https://developer.mozilla.org/en-US/docs/Web/API/MediaDevice... )
In C++ land, you are ultimately going to either need to cook up your own webcam library or look for a 3rd party (which, in 2010, likely didn't exist) to provide it.
Today, there are a few easy to discover rust crates which provide cross platform webcam apis. But further, rust does cross platform better than C/C++ IMO. It's really easy to change how code is compiled based on the target. That was all well thought out because rust was supposed to be a language for browsers.
I think people become super lazy... "Ah, it's will ocupie a few hundreds of RAM, no problem, let's ship it."
They are companies with billions or even trillions shipping shit with Electron.
Hiwever, I'd like to hijack this front page article to for a related concern/question I've got.
It seems that all (popular) opensource LLM harnesses are either in JS or python (pi, hermes, opencode, paseo). The same seems to be true for closed source harnesses that I have used (deepseek, chatgpt).
I'd really like to ask why? I mean why somebody would use technologies like JS or python to implement a harness application instead of golang or rust or even C? I understand that before 1 year JS or python would be tempting but right now? Especially the LLm related companies have unlimited tokens and re-writing the harness software to golang or rust should be trivial.
This would benefit so many people (especiall considering the prices and scarcity of RAM these days).
So, why nobody does it? This is an honest question, I don't want to offend interpreted languages but it should be a universal truth that a compiled language is faster and consumes less ram.
This bit is obviously subjective, but Rust as a language is simply not ergonomic enough for a lot of the use cases people are trying to apply it to, especially UI development. Most of the Rust UI libraries I've seen to date either use a more imperative style, or attempt to replicate more declarative approaches like Compose UI or SwiftUI, but without the nice language aesthetics that make it simple to read and write. And if the counter-argument there is for LLMs to be reading and writing this stuff, that's a whole other can of worms: (1) The subsidized inference era is quickly coming to an end and (2) if you're using LLMs anyway, why not maintain apps that are as native to each platform as possible?
The only way to ship the same code between linux, macOS, and Windows would have been to either use something like Qt or the JVM back in the 2010s. The JVM desktop stuff was super ugly and Java itself had become notorious (also if you wanted anything remotely interesting like webcam/microphone or multimedia access you'd still have to ship dynamic libraries). Qt required special packaging skills to ship to the end user especially if third party libraries were involved. Electron killed that by bundling chrome (and chrome has a huge api surface).
Today, I would argue the package management situation for a language like rust is a lot different. You dont have to cobble different DLLs together, you can just statically compile dependencies and cargo/rust do a pretty good job of making sure it's bundled with your app. Other languages also now have similarly useful tools.
Election predates WebAssembly by 5 years and hit the scene only one year after Rust was first created.
And just like JQuery, its time is coming to a close as better frameworks are available now that weren’t available back then.
At the time Electron came out, there weren’t as many cross-platform UI frameworks available that they could have gone with.
You can see this with the comparison chart. GPUI effectively replaced Electron so the desktop app UI works across platforms. React Native is replaced with WebAssembly so that Rust can be the primary language across all platforms including mobile.
It seems like the new situation for Discord is rather elegant, and that none of this would have been available when it first came out.
Most Rust GUI toolkits, at least in 2025, did not have that good accessibility or IME: https://www.boringcactus.com/2025/04/13/2025-survey-of-rust-...
Hopefully this has gotten better and the new discord client isn't worse in that regard.
For a long time, and mostly out of frustration, I wanted to build my own stack of software around my vision. But the mammoth amount of effort it would require meant I never went through with it.
You show this by all your other comments on memory. The reason apps take memory is Electron.
Plus I prefer apps that behave like OS native apps not the reduced GUI of web apps.
I don't know...there seems to be something unpleasant about all Electron apps.
With the ram prices as crazy as they are. It's pretty frustrating to have to run multiple GB eating applications just to do some basic tasks (90% is read and write messages, in the case of Discord). I understand that other people might use the more advanced features (voice chat, etc) but these could be loaded on-demand.
It's a bit crazy to me that I can comfortable run an entire Linux stack (+ Podman, monitoring, alerting and multiple services) in 512 MB ram (with 40% free, just checked!). However my Windows PC needs 5.5GB just to show the desktop! Realistically it needs somewhere between 8GB and 16GB for some basic web browsing and even then it can feel slow if you have a few apps like Discord running in the background.
Electron's value prop has always been about having one team producing one app that is supported on multiple platforms with minimal additional effort.
This article does nothing to address that.
For fast emergency destruction of documents, the NSA has developed a procedure https://media.defense.gov/2021/Jul/02/2002755769/-1/-1/0/EME... where paper and oxidizer get layered in a burn barrel. "The ratio which was adopted was 65 pounds of paper for 100 pounds of nitrate" gives you an idea how much extra oxygen is required for proper combustion.
The fuck we will give free reign to Claude to vibe what's secure and what's not and what it can't do.
I want fully static control over certain folders. Permissions rules should be ABSOLUTELY enforced sandboxing (even without the user bothering with custom sandboxing themselves) on top of any mode, manual or auto.
Claude Code doesn't even have a basic 'enqueue' prompt feature. Even though Copilot CLI, Codex and many other harnesses have had this for a long time now. And the GitHub feature request for this was closed, by you, referencing a completely unrelated feature.
My view is that if the agent can decide to do something, nothing stops that thing from being done accidentally, and any attacker that can inject text into its context can do that thing.
Recent GPT and Claude models have this tendency of using super complex Bash commands. This makes sense, if your RL rewards optimize for min(tokens) and max(performance), it is better to waste a few tokens on a complex inline Bash script that runs a few commands at a time and returns just the output you need, rather than doing one simple command per turn and paying the cache read on every turn, like older models used to do.
This, however, is a problem both for command reviewability and sandboxing. With the older way of doing things, without auto mode, most commands would run sandboxed just fine (especially in Codex), and you would only be asked for approval when a command couldn't run in the sandbox. With everything being stuffed into one complex script, almost every script fails in the sandbox and requires you to manually approve it, and the complexity of the script makes it hard to understand what you're actually approving.
In other words, new models optimize for effectiveness, with some attention paid to human understandability of their output, but almost no attention paid to human understandability of tool call arguments (Bash, inline Python). This suits auto mode and giving the model larger tasks, but not the way of working that some people prefer where you watch over the model's shoulder.
More and more I feel like I'm fighting Claude: it edits multiple files using python scripts and it edits in parallel so if I stop it, I have to stop each individual edit. Both of which I've told it not to do repeatedly, but it still does then apologies which is worse.
Claude respects nothing, especially in auto mode, and effectively behaves like a virus trying to get out of its sandbox. That Anthropic employees are so relaxed about it is incompetence.
Imagine people who naively run Claude natively on their host machine and have client lists in other directories.
I appreciate that you're trying to make Claude Code safer, but the agent really needs to be a lot more restricted in its reach rather than its actions.
The agent should NOT have ANY access to:
- Your ENV
- Your homedir
- The network at large
- ANY other directory on your system
- No, not even your workdir.
The only safe way to use an agent is COMPLETELY isolated by a container or VM, using git semantics to extract its output.
With e.g. VM or container sandboxing, we can say things like "If there are no vulnerabilities in the hypervisor or hardware, then the agent can only access these files, these network services, etc". Auto mode doesn't even try to provide any guarantees, so it's impossible to reason about. It amounts to just using the models judgment about what's "malicious" or not, a definition which is subjective, changes model to model, and can be influenced by attacker input.
Empirical evaluations of how many vulnerabilities manual vs auto mode let through are not super meaningful because auto mode changes dramatically with model releases, the type of task being performed, whether the attacker is making targeted attacks designed to bypass auto mode, etc. A security feature cannot rely on these sorts of factors if it's to be taken seriously.
Further, percent of malicious tool calls accepted is a bad metric. It's like measuring the security of ssh in terms of what percent of unauthenticated logins succeed. The only acceptable value is zero. It's pass/fail, not a spectrum. So both auto and manual mode should fail equally here. Further, the set of malicious tool calls admitted in auto mode may not be a subset of those admitted in manual mode.
Whereas that should probably be default on instead, and this should apply to other known sensitive folders. A simpler system like .agentignore would be even better.
I like auto mode but "the agent supervises itself" is a bad compliance/safety answer on its own.
This is called "approval fatigue".
If you think this can't possibly happen to you, you might be in for a surprise. This is an almost textbook case of classic conditioning. You'll find yourself hitting that button faster and faster even while fighting back the urge. So a human is no guaranteed backstop.
This is the scenario that cc auto mode guards against. It cuts down the number of permission prompts to something manageable, so that your fingers don't get trained into clicking 'approve' on 'rm -rf' in the very eyeblink that it appears.
So maybe you feel it doesn't work in theory; but weirdly enough, in practice this particular approach is actually one of the better ones; especially when used in combination with other common sense measures where practical.
sed -n 1,30p src/vm/wren_vm.c && sed -n 310,350p src/vm/wren_vm.c && sed -n 560,600p src/vm/wren_vm.c && sed -n 740,775p src/vm/wren_vm.c && sed -n 40,70p src/vm/wren_common.h && cat util/wren_to_c_string.py | head -80 && ls test/random doc/site doc/site/modules doc/site/modules/random 2>/dev/null; cat projects/premake/premake5.lua | head -80; cat util/generate_projects.py
After ten or more of these, you're going to get hit by permission fatigue, and then, yes, manual review becomes too error-prone to use safely.
The irony is that Claude is regularly ignoring its existing Read/Write/Edit tools that could make everything more readable.
Other models/harnesses have their own problems, but Claude Code is one of the worst for manual approval.
You can get manual approval to work reasonably well if you give the model a reasonable set of tools (I have literally written my own MCP servers to cover gaps in existing harnesses) where you can then write rules for the vast majority of safe cases.
For example, I have a stdio MCP server that allows models to inspect crates under ~/.cargo/registry/src (paired with the existing query-crates MCP server). It provides read-only operations limited to crate data, so I can pretty safely auto-approve everything in there. With the right setup, including a sandbox, you only ever have to manually approve something once in a while and usually with delimited scope, avoiding permission fatigue.
This is an absolutely crazy statement without also bundling proper sandboxing. Nobody should be using auto mode outside of an environment they'd be happy with an 'everything is approved' mode too.
That is not the niche case, that's the dominant use of models.
It would be helpful to distinguish between your own opinion on how models ought to be used, compared to how others actually use models.
$Trillion AI company asking for ideas from the community whose work they hoovered up to make money, ruin an entire industry and make lifetimes of hard earned skill completely valueless in the span of 2 years.
A fresh clone wouldn’t have the file. This claim doesn't make any sense.
The only way I can see this getting committed is if someone edited their global .gitignore or, more likely, did a whole directory transfer to do a different machine to work on.
Many of the problems when it comes to the manual approval feel like they stem from the expectation of using auto mode in the first place. After all, what's the point of improving the manual approval and safety matching if auto mode is the end all be all, and what's the point of training the model to output commands in a manner that can be parsed by a human if auto mode is always meant to be used? It's very rare for me to not see "command could not be statically analyzed", because the model keeps outputting bash golf.
Ultimately, the threat model here is: human has to approve a lot of commands, so gets tired and accidentally approves a command they shouldn’t have. We spent a significant amount of effort to build a richer permission system, allow configuration at multiple levels, use static analysis to detect dangerous and safe commands, monitor the model to detect and block prompt injection at the inference layer, etc. Some of these components we rewrote and red teamed dozens of times. Our conclusion was that despite all of this work, in practice the threat model is that human attention is limited and that that a different approach performs an order of magnitude better in practice.
That said, a few thoughts:
1. .claude/settings.local.json is meant to stay local. This is not a file you should check into source control. We automatically gitignore it when Claude creates the file, so in this case the files were manually created and checked in (docs: https://code.claude.com/docs/en/settings)
2. Permission rules are old hat. Everyone should be using auto mode instead. It is safer and also does not require manually maintaining finicky allow/deny lists. Auto mode is enabled by default and is included for free in all plans.
3. Regardless of what agent you use, you should have secret scanning enabled. GitHub and other source control hosts offer it. There are many threat models that it protects against and you should absolutely use it if you can. (see https://github.com/security/plans)
If you post output from AI, please remember to edit before publishing
So pressing “Don’t Ask Again” by itself doesn’t expose passwords by itself. If you commit your local Claude settings and in those settings you have manually approved commands containing secrets directly in the command and then you publish the repo, that’s exposed.
You can get something to manage TUI sessions, but GUI has that by default and is better than the tools I've seen for TUI.
My one thing with the GUI is sometimes I wish I could have more windows open but /side solves 95% of those issues.
No it hasn’t, this is a very recent addition. Previously you had to symlink CLAUDE.md to AGENTS.md, or include a @AGENTS.md in your Claude file, but by itself it would not read it
Not only it's a GUI in client-server topology, it can also orchestrate the agents to work for you.
Haven't tried it yet.
After testing several options at the moment I'm using Orca IDE as my daily driver - effectively as a layer on top anthropic / openai
- Supports both anthropic and openai with subscriptions and can you swithc easily between those two + other LLms
- Its a bit hidden / non intuitive to setup but it does support running everything on remove host -> I run (95%) of my jobs on remote hosts that I can both access from my laptop + their native app via a wirguard vpn
- You can switch between chatview + TUI on the same conversation - very useful if you move e.g. from desktop session to mobile view.
- For repeating LLM tasks Orca also suports a kind of scheduler - but I prefer currently to have the agent set things up via chronjobs on the remote machine (not super happy with this ...)
Key reason I dont want to go fully ChatGPT/Claude is also I dont want to build a super strong dependency on those mega players and remain the ability to switch to other interefernce providers / models.
As LLM usage is already a core workflow in our company - a sudden unavailability of one or a massive price increase - makes it absolutely necessary to build out alternatives.
We all know the downsides of SAAS Lock in too well from the 2010s. In that sense Fool me once, fool me twice..
A GUI is strictly more powerful than a TUI (because a GUI could just show plain text in cases where that is the most appropriate mode of interaction, E.G. Bloomberg, AMadeus), but it could also do so much more in cases where it is not.
I do love terminals, don't get me wrong. When what you're interacting with is CLIs and Unix tools in a shell, a terminal is exactly what you want. I do love the Unix philosophy, I like small and composable tools that you can use together, and I think the interactive way of working that a shell or REPL can give you is great (though notebooks would have been better, but that's beside the point). Those are things that the terminal shines at. Pretending to be a GUI is not one of those things.
I cannot get behind CC is the best harness. Once u switched to pi I knew I was never going back and occasionally I need to use CC for my subscription and find it unpleasant. CC is just this incoherent hodge podge of functionality that seems to have no vision. Subjective, of course.
My interruptions and frustration with llms has gone down a cliff. It’s amazing to see what just a few lines of system prompt really can do to keep agents doing the correct thing much more often.
1. Potential ban due to ToS violation;
2. It doesn't follow all Anthropic's communication mechanisms out-of-the-box, they heavily use custom headers, hidden flags, and undocumented API features that affect models' behavior;
3. Compact is better in CC (significantly);
4. Cache related nuances (I mean, A\ regularly messes up with cache even in CC, their caching is non-trivial);
5. It's almost unavoidable to use Pi's extensions, and I wouldn't trust my oauth token to anything third-party (take a look at regular reddit/X posts where people getting banned due to such leaks and abuse) -> it takes enormous amount of hacking on top of Pi to get closer to CC abilities.
CC has hooks and mods, even ui_* (undocumented) protocol if you need some big customization, those are enough to implement whatever you want on top of CC.
Also, I'm working with CC from the very first versions, as for me - it's the best harness (as-is) on the market. I have zero clue what problems people are talking about (except known big issues, 3-4 over the years, I've never had serious problems, at all). Seamless and smooth experience, optimized for Anthropic models.
P.S. You can consider this as Stockholm syndrome effect, but... you have close to zero chances to get unbanned with Anthropic, and it's the best coding model(s) available today.
Take a look at the Codex App Server or the Claude Agent SDK as a way to communicate with harnesses running headlessly and build your own UI on top. I’m sure Pi can be set up in a similar fashion.
The GUI is less verbose with the nitty gritty hidden in expandable sections, which makes history easier and cleaner to scroll through, also no scrolling bugs, rich text is easier to read with tables, and images integrated into the chat, resources like browsers in the context of the session. Drag and drop session organization (pins), scheduled tasks, etc.. all that in the side bar.
Usually a TUI would be open in VS Code and scoped to whatever repo I'm working with so 10 projects, 10 VS Code instances open, not super scalable. With the GUI desktop app it's one app, and I can start sessions in an repo and switch between them easily, no need to open VS Code for each. I don't see what could make me want to go back to using a TUI.
Who else is just using the GUI nowadays, or are you still on the TUI, and why, have you tried the GUI interfaces?
> Forgive me for asking if I should know, but who is the author? Is he famous?
I think that was tongue in cheek. And by that I don't mean the author's tongue was actually in his cheek.
I also think it went over your head. And by that I don't mean I think it literally went over your head.
(For the record Tesla makes roughly 10% of Toyota's profits and has almost 3 times the valuation, no Tesla shareholder is ready for a 97% share price drop so Tesla has to keep the dream machine at full steam).
Edit: Tesla is 3 times Toyota in valuation, not 5 as I said earlier, not that it changes the argument much.
Anthropic is way more focused. That helps in a way that builds upon another: their product tends to be better and the people's perception of it as well.
But "much less"? OpenAI needs a month or two of good choices, progress & announcements, and that flips. On the other hand, Deepseek could blow both out of the water unexpectedly, ending the argument about who has the superior tech.
There's also the Elon factor. Anthropic has a good relationship with Elon (to the point where he discounted the compute sold to them by quite a lot) while OpenAI/Sama is the devil to him.
Going for the IPO collapses a large space of options that are available to the business. The AI business is entirely about data. Anthropic's IPO would generate an incredible amount of data that could be used by its competitors to refine their strategy. Knowing where to allocate capital is perhaps worth more than the capital itself at these scales.
What makes you say this?
Unless things change considerably, this is less than a 6 month runway.
It's not common for raises to give you this little runway.
You could read into it that they expect to IPO in far less than that amount of time, and this is a short bridge until then.
This will also make it even harder to avoid any future IPO being a down round. They’re almost certainly worth much less than Anthropic and Anthropic is, per reports, struggling to keep its valuation much above 1T, and even that may fall through.
https://www.wheresyoured.at/running-dry/
They got a bit of pocket change at this insane valuation.
I liked the security model because at least they had something, unlike node.
This used to work just fine.
When my phone is sitting on my countertop and I say "hey siri, add eggs to my shopping list" I expect it to add eggs to my shopping list, as it has done so for years, instead of saying "you'll need to unlock your iPhone first."
When I'm driving my car merging onto the highway and I see furniture on the ramp, and I say "hey siri, call the local non emergency police department number" so that I can report it, I expect it to say something like "I have the [city name] non-emergency phone number, want me to call now?" Instead of it saying "calling the New Jersey police department" which is halfway across the continent from me, and then giving me no way to hang up the phone hands free forcing me to grab my phone from the console and quickly try to hang it up while I'm driving at highway speeds.
You can set up a digital twin of your actual workshop, with config-driven models of table/band/miter/hand saws, router tables, drill press, chisels and rasps, all sorts of fun.
I recently added a jig system too, so you can build jigs that you can actually use, both in your shop and in the tool. It's all drivable by a human or an MCP, and has video and plan authoring and sharing built in.
I've been building this as a labor of love since getting laid off in April, it's all completely free to use and people have made some really damn cool plans with it.
[0] https://sawdust.diy