Hacker Newsnew | past | comments | ask | show | jobs | submit | eddy162's commentslogin

Saying the answer is auto mode almost feels insulting as a developer. Claude loves showing me the most obscure bash commands where it hides its edits to numerous files and runs who knows what that there's barely a time where I don't have to ask it to use edit mode and to show human-readable bash commands. Using Claude has become a fight in maintaining control over how my codebase works so that I'm not dependent on Claude to do literally anything.

Genuinely want to understand this better. Are you saying you would prefer that Claude used the Edit tool for file edits rather than using Bash (if so, I am curious why)? Or are you saying you don’t like the code Claude generates (if so, what model are you using what what kind of codebase do you work on)? Or did I misunderstand what you meant.

I tell Claude not to use git or maven, and has a VM without those binaries. Later on, it was trying to push on GitHub. It had downloaded the git binaries from the internet, read my .git repo, used the remotes written in it, performed a commit and pushed it. All against my orders and against the CLAUDE.md file. Fortunately it didn't have my SSH key or my ~/.m2/settings.xml. And .git is now mounted as read-only.

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.


It’s not ideal for non technical people but the way to prevent this is to use hooks. “Telling” Claude is not going to work.

It means Anthropic has massively failed at developing a trustworthy product.

If AGENTS.md/CLAUDE.md isn't followed, auto mode doesn't provide any guarantee, yet such practice is promoted everywhere including on HN like this as if that's something you can set and forget, I think there is a problem.


It's trustworthy... most of the time. For 100% use hooks.

Memory files routinely overgrow their accessible size. Agents need constraint with contracts and external tooling. Even then they can attempt to cheat the tooling. Again task management with integrated logic will enforce behavior of agents.

not the OP, but generally, if you don't want to / can't use auto mode for some reason, you want Claude to make its actions as reviewable as possible.

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.


> 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 is not a good reason. Models can emit batched tool calls, which a smart harness will process all at once without starting a new turn. I see it in Zed all the time. In fact, Zed processes batched tool calls concurrently, which can be faster than a chain of Bash commands, and failure of one part does not cause failure of subsequent parts chained with `&&`. This approach is token neutral and easier to understand.


I have a standing instruction telling the agents to prefer to use ruby wherever possible. Ruby uses fewer tokens than Bash and is easier to read, especially when condensed into a single line.

Of course, that only helps if you’re familiar with ruby. And the agents sometimes still choose Bash regardless of the instruction.


I was in this boat also when my company didn't allow auto-approval. Bash and python scripts are a pain to revieve.

Though I think this is largely transitory, we are already in a place with the harnesses and models like Opus 5.5 that the kinds of work you are doing involve so much that vetting everything manually is probably less efficient than setup up access control on the prod routes or dangerous resources.

I'm typically giving tasks that invlude multiple actual repositories and systems at the same time.


I think 2024's method of manually reviewing bash commands is unsuitable for modern agentic development. Whether that's something they want to optimize Claude Code for is their call.

That said, I've also seen problems from complicated bash calls with Opus 5.5 on xhigh. Occasionally git push hangs and it believes it's waiting for an hour for git hooks.

The actual reason apparently was that it incorrectly piped git into grep, resulting in a deadlocked command.


> Recent GPT and Claude models have this tendency of using super complex Bash commands.

Are you sure? I read its proposed commands (auto mode is hard off for me), and mostly it seems to string together fairly simple info gathering commands (ie grep's, echo's, that kind of thing).

I don't tend to have it write much code recently though, instead I'm having it investigate config files/code bases, and that kind of stuff.


Reading files with sed instead of the Read tool is ridiculous. Writing a Python script via bash cat <<EOF is ridiculous. The model has learned some weird habits.

I've seen it propose sweeping edits as a one line sequence of sed commands targeting specific line numbers. The only way to review would be to manually look up every line number. This despite by local instructions telling it repeatedly to prefer the standard Edit tool.

I have this same frustration. The way I use Claude is for it to make edits one small chunk at a time so I can review the code as it writes, and to make sure it's going on the right direction. I find this much easier than generating a large pr I need to review.

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.


This is solvable. Opus has adhd. Myself and others solved this by building ticketing and task management systems. The task constrains the agents actions and focuses the effort. Every update is catalogued. It’s easily reviewed and referenced. Opus doing terrible things and apologizing is not surprising. I’ve moved to a system of multiple agents reviewing and authoring changes. Convergence generally always results in a positive commit.

I feel this way as well, Claude writes completely incomprehensible shell commands all the time. Trying to understand them is like deobfuscating code and I have basically given up, but I'm not happy about it.

Even if I could follow them I would also prefer it use the edit tool, since I find Claude also introduces lots of "minor" changes I did not ask for when it rewrites code in bulk.


Not OP, but if I understand their complaint correctly, they're saying that on auto mode claude does a lot of things in obscure ways with "clever" (i.e non human readable) bash commands that perform multiple operations and OP feels they are losing control over their codebase and so they opt for edit mode where they get to review what commands claude runs.

Editing local files is not where you control your source code I hope.

Just tell Claude to never commit or push.

You are in control of git, Claude is simply a tool to quickly apply changes to local files for something you want.


Yes, why should we do the things in easier and more comfortabke way (review small changes) when we can force user into harder one (newest changes mixed with all previous ones).

I just review the MR

So basically you gave up?

What does this mean?

A Merge Request or Pull Request is the only thing that makes sense to review, and always has been since before LLMs.

If some author tells me “you can review each commit to make it easy” I will ask them to make separate PRs.


>A Merge Request or Pull Request is the only thing that makes sense to review, and always has been since before LLMs.

Why doesn't it make sense to review smaller units of change within a big PR?


Not GP, but in my experience, those small changes are usually contrived to be small. Like saving snapshots instead of being atomic and self contained. And if they are the latter, they should have been separate PR.

That’s why I usually look at the diff of the whole PR and prefer to merge by squashing. Commits inside the PR are usually noise.


What you are saying is true if created manually. It is a chore to create sensible commits messages when you are committing often.

But LLMs appear to be pretty good at making small commits with sensible commit messages, that greatly help to make sense of the whole PR.

Regarding large monolithic commits, how do you even know where to start reviewing in a large PR? Smaller commits at least give you some sense of ordering.


> Regarding large monolithic commits, how do you even know where to start reviewing in a large PR?

What I’m saying is that large commits shouldn’t be a thing without out of band discussions (formatting, design refactoring, features merging). With such knowledge, it’s easy to glance at the code and understand the implementation.


>without out of band discussions..

Not every project can afford this.

>With such knowledge, it’s easy to glance at the code and understand the implementation.

I really doubt that this is true for large, legacy code bases, where one is only familiar with a small part of the system.


> Not every project can afford this.

You expect to send a big PR to someone without him being aware of the context or without being available to discuss your solution?

> I really doubt that this is true for large, legacy code bases, where one is only familiar with a small part of the system.

Reviewers should already be knowledgeable about the part being modified. If no, the review is just for checking for antipatterns in the code, or badly written tests. A bit useful, but can be unnecessary in high trust (or keen on accountability) workplaces.


It is not that I expect it. But instead, it is just about being realistic about how real world projects differ in workflows and conventions. If what you describe is not available, then the next best thing is to make the reviewer aware of the context and solution by means of small commits with sensible descriptions.

It means you gave up on getting claude to show you changes as it is doing them, in a comfortable form, so that you can steer it as it is doing them.

Nothing more comfortable than having to use git commits and branching just for telling the agent which lines it messed up instead of simply not writing the garbage in the first place.

I’m also not the poster you’re replying to, but yes, I’d prefer the edit tool over the ad-hoc string replacement scripts Claude seems so fond of. I’m not always reading tool call transcripts (source control diff is usually sufficient), but it’s a lot easier to read the edit tool output than the same thing as quoted shell (or Python, or Ruby) strings.

Unrelated, but I frequently tell Claude to use the Edit tool instead of bash/python scripts because it regularly times out for 2 minutes because of a mangled heredoc, extra character (-, \, ...) that causes the script to hang.

This instruction is in my toplevel CLAUDE.md but is somehow generally ignored.


Which one uses more tokens? That might explain why it's ignored

Touché

As a happy Claude Code user (thank you!), I’m genuinely curious why it prefers Bash or Python scripts to the Edit tool for editing a file? as a software engineer, surely the complexity involved is lower for the Edit tool?

Would love to hear the rationale/explanation behind this.


RL magic, I'm sure. It still reaches for the Edit tool for simple edits, but a non-trivial fraction of edits need to be repeated across a file or several files.

I used to lose my mind because CC in VSCode would use bash instead of the edit tool which meant parsing esoteric bash instead of reading a nicely formatted diff in the editor.

Yes I always have to tell it to knock it off, it will ignore memories about it while apologizing for ignoring the memory. I want to know what the edits it's making are.

Thanks for replying!

What I'd love is for Auto Mode to show the full diffs one-by-one as they're being implemented in the CLI (or VS Code).

On top of that, an option where Claude explains what it's doing in every step, as if you're watching someone talk while they implement a coding challenge, would be really helpful (and would also reduce interrupting it when it looks like it's deviating from the Plan).

The use-case this would support is to have a full understanding and confidence in what Claude is doing while it's implementing a Plan in Auto Mode. The reason is that it's much less tiring/overwhelming for me to follow along an implementation compared to reviewing a giant PR after the fact, and it's helped reduce my coding fatigue by a lot.

Edit Tool:

Currently I tell it to use the Edit tool because it doesn't reliably show the diffs in Auto Mode (I have the latest version; I've sent numerous feedback reports on this), and later in a session (when implementing my feedback) it will often make multiple edits in some unreadable bash command. So my only option to see the full diffs during implementation and to have it explain/break down bash commands is to go into Manual Mode.

Documentation & Comments:

Even with an initial prompt instructing it so, Claude always needs to be interrupted so that it will rewrite comments to something readable to humans.

While very long "technical"/Claudish paragraph comments and MD files might work for future Claude's (and improve benchmarks/coding scores by making implementations technically more comprehensive), my goal is that a human coder should be able to understand how the codebase (React/Node/Python/Polars) works by reading on their own rather than needing their own AI to summarize everything.

I've even seen it rewrite existing human-written concise comments into blocks of Claude-ish, as if it's trying to make everyone dependent on it in order to do anything to the codebase.

I wonder if an optional built-in skill could help improve this, as I admit I haven't experimented with building any of my own (my concern with customizing Claude.md is to not overload it with too many instructions; I'm on vanilla Claude Code). Note: This is all on Fable on xhigh.


I don't use claude code but whenever codex uses a command to write code I do not get the diff of the patch for manual approval so I just straight up reject it.

The entire approach is insane. Ideally Claude ran in a microvm locally with delegated auth or proxies to avoid it having greater access than granted.

I run it in bwrap so, even if I'm running on Linux, I don't pay the cost of some layered file system and building the docker image. I mount some directories read only, the project repos read write. A VM would provide more isolation but it's a matter of tradeoffs.

BTW, I just checked and my .gitignore files ignore .claude

Claude and any other program in my laptop could upload it anyway to any attacker controlled server. It's the usual threat analysis: who you want to defend against, what and the tradeoffs between cost of the defense and probability of the attack. Auto mode of not auto mode is in the cost of defense part IMHO.


I’m kinda surprised Anthropic doesn’t do this by default. Asking permission meant what felt like near-constant manual intervention. It almost made a joke of the agentic claim. It also became mostly useless, as the size and complexity of the scripts meant a brief scan wasn’t likely to find anything anyway. Yet they persisted with it for so long.

The sandbox seemed like a good replacement. For those of you who don’t know, the sandbox means Claude Code runs with no protections itself, but it runs tools inside something like bubblewrap. It looked impressive until the model solved some commands failing by giving itself permission to run them outside of bubblewrap, defeating the entire scheme. When I first saw it do that, my reaction was “you can’t be serious”. But apparently they were.

So now I’ve adopted your solution: run it in a container, like bubblewrap, where I control the permissions at startup, so no model can bypass them. Add --dangerously-skip-permissions and you have something that’s workable and safe enough. A hallucinated space in `sudo rm -rf / $R` isn’t a disaster. Real damage outside of the project requires a level of malicious intent I’ve never seen from an Anthropic model.

Workable, but it doesn’t work 100% of the time. Claude Code stores stuff in a myriad of places, which makes setting up the sandbox far harder than it could be. Worse, the way it writes configuration files requires bwrap to give write access to your entire home directory. No way I’m giving it that, but without it, it can’t auto-update or refresh login tokens.

If they rearranged a few things, Anthropic could make it much easier to run Claude Code in a container. They could even make it an option supported by the claude CLI itself.


Hah, I normally run it in a docker container myself, and only mount the project directory. Anything else it needs, I copy in for it, or occasionally I'll ask it to write an rsync.sh that I can run to bring in the stuff from outside.

This is exactly how my employer runs Claude. It gets r/w to the cwd and read only access to a bunch of whitelisted nfs. All web access goes through a proxy where internal resources are whitelisted

Proxy also lets you bootstrap auth tokens at proxy layer without giving clause access to the auth identity. Greatly limiting the exfil risk.

[flagged]


10 millions developers doing something stupid does not make it right!

[flagged]


Imagine that I am working at the AI company, and my friend has some bone to pick with you. My friend asks me to ask your AI agent to put some unsafe photographs/videos in your computer and do what ever necessary so that it looks like you put those files there.

Then my friends tips off the cops. And your life disappears! Gone!

And you didn't get a chance to share your story because I don't think you ll have wifi where you would be going, and frankly you are too clueless to imagine your AI agent doing something like that...


Tell that to everyone whose agents posted their secrets to GitHub.

Yeah I have a whole ongoing thread with Claude where I paste in screenshots of all the bash prompts auto mode is triggering asking me to allow them. After about two weeks of doing this and having it update its settings.json permissions or showing me which lines to update, its finally able to complete most (inherently safe, low risk) tasks without user intervention.

Or how it loves using ; to chain commands so that even if the first part fails to run it just moves on the execute the rest, wasting time and being potentially dangerous. I have caught so many of them myself and stopped tasks manually -- what is it doing when it's obvious tests already failed in the previous step?

Their "auto mode rules", meant as additional rules described in natural language to adjust auto mode because, doesn't even help. I have to add a PreToolUse hook to stop that.


Yeah. Boris, you and Anthropic need to stop pretending "just trust me bro" is a security architecture. It's a self-aggrandizement architecture.

Claude will have auto mode turned on whenever she's locked down on a meticulously isolated machine, with carefully managed proxies that I control deciding (and logging) which agent with which access patterns is allowed to access which resources, locally and on the network. Anything else is malpractice.

My opinions do not represent those of my erstwhile employer NVIDIA Corporation.


Why would what you write in a random comment section represent anyone else? Are you that afraid of lawsuits you can't even comment online?

Corporstions will use anything they can against you, either for profit or someone's ego.

Next tell me why it's important to write "I'm not a lawyer" as well won't you.

It's to help people realise that your advice might be wrong and they won't have any recourse against you for reparations - but in many jurisdictions, it's actually illegal to give legal advice if you're not registered e.g. regarding immigration.

> dependent on Claude to do literally anything.

That's a feature not a bug


Plan mode is what makes it easy for me to update my mental model of the codebase, and helps me decide if the mental overhead of all the changes that are needed are even worth doing, which are now the biggest limiting factors (reading the code diffs just doesn’t scale anymore).


Felt like this read my mind, I was shocked recently at how good Cursor (with Claude) is at answering questions given its Slack/GSuite MCP connections; and a lot faster than Glean. Also amazing to see how this can literally give better answers than some humans would.


Yea me too! I had a sense that something better than pure document retrieval was possible. But wasn't sure what. I spent months just playing around with various RAG techniques until coming up with this. I do think something like Glean is still needed (the agents here used Glean search API for building this context layer). but for the purposes of answering questions and building enterprise-ready agents, the ECL is probably it


Agreed on Glean still being needed for retrieval. One gap worth noting though: Glean's enterprise graph on the people side is mostly org chart and document co-occurrence data. It doesn't capture who people actually trust, who informal decisions route through, or who the real subject matter experts are regardless of title. Organizational network analysis on top of that could be a meaningful additional layer for the ECL.


Work in the industry: way too many planners and transit consultants are fixating on too many stops as being a problem, likely since it's the one piece of infrastructure they can control when roads and traffic lights are designed for cars not people.

Depending on the road network and land-uses, removing stops only 200-metres apart to make them 400-metres apart (the industry standard) could decrease access to transit within a 5-minute walk by anywhere from 10-50%+, so it's limited to where you can actually apply it without penalizing (ie. putting them outside of a 7-10-minute walk) so many customers that they look for alternatives.

In Europe stop spacings are much longer even for local routes (over 400-800-metres), but this is because everyone generally lives within walking distance for their errands, so transit is used only for longer, more commute-like trips, where a longer walk for faster travel times makes sense. Accessibility is also less of a priority there so they're less sensitive to requests from seniors and those with disabilities, with many buses not being wheelchair accessible. In US/Canada, a lot of transit riders live over a 20-30-minute (often with hostile walking conditions like crossing highway ramps) walk from the nearest grocery store, school, pharmacy, etc., so they'd oppose adding 2-3-minutes of walking to shorten a 10-minute bus ride.

Moreover, closely spaced stops are really only an issue in older (pre-war) downtowns where frequent stops are the result of decades of requests from residents (especially seniors) and from schools/churches/grocery stores/retirement homes/medical clinics. Out in the suburbs, buses usually bypass most stops, and schedules take that into account. And in places with amazing land-use like Pheonix and Vegas, you have long stretches of nothing so of course there'll be higher average stop spacings.

Lastly, much of the time-savings from express routes (that skip stops) and bus stop consolidation/balancing, is from being more in sync with the lights, which are usually designed for through traffic (ie. a green wave). Transit Signal Priority can help achieve significant savings (over 10-30%+) without removing any stops, though moving stops to after the light makes it more effective (and even that can be politically difficult).


Amtrak just added a new train from Minneapolis to Chicago to fix this exact issue as delays on the Empire Builder tend to be worst in the plains/mountains, so hopefully you can give them another chance: https://www.amtrak.com/borealis-train


I'd never heard about Placemark yet this fills a gap I've been seeing in the mapping market having worked in local government - data management in ArcGIS is $$$, awful, and limited to a handful of GIS specialists, while Felt has nowhere near the data capabilities like joining and transformations that Placemark has. The real money in mapping is from enterprise & government, which requires a lot of upfront work to sell to. Hopefully other companies in the space (like Scribble Maps, Felt, or Esri via ArcGIS Online) fill in some of the feature gaps left by Placemark.


This is super super cool! This kind of visualization is so much more useful for finding a transit-friendly spot to live than the generic TransitScores real-estate websites have. Would be nice if the frequency of bus routes could be visualized too, and hope you find a way to add more cities painlessly. Having worked in transit planning, this is really useful for network gap analysis - like finding areas where connectivity could be improved.


Two big differences between taxis and Uber/Lyft, which explain their massive losses and weren’t mentioned by the article:

1. They provide insurance: It’s estimated that around half of Lyft’s operating expenses are for insurance [1], which in their filings is mainly under Cost of Revenue but some settlement expenses and other non-mandatory insurance coverage would be under General & Administrative [2] [3]. This was pretty surprising to me, as I never thought it’d be this much.

2. Costly driver incentives: Technically this is under Sales & Marketing, which is around 10% of expenses [2] [3]. However, Uber/Lyft can choose how much of a commission to take so that the driver keeps driving, so the incentive would then come at the cost of lower revenue.

These are vital to their operations because:

1. Commercial insurance could cost $400-700+ a month [4]; taxi drivers pay this themselves, but Uber/Lyft drivers don’t, paying a much smaller surcharge to their personal auto insurance because Uber/Lyft cover third-party liability during rides.

2. They need lots of drivers driving around in order to provide short wait-times. Outside of city centres, the wait-times for taxis can be pretty long, often requiring a reservation made hours in advance. Uber/Lyft gave people the freedom of owning a car at a price usually not more than $5-15 over a transit fare.

But being able to provide a ride in just a few minutes anywhere in a city even late at night isn't free. For instance, in NYC around 41% of driver time in 2018 was driving around waiting for a ride [5], which they aren't paid for. If there are plenty of drivers, Uber/Lyft can profit off them and let them churn, but if they're needed to properly serve an area or time-of-day (ie. keep wait-times low), that's where retention bonuses and letting them keep more of the fare come in as to motivate them to keep driving.

So in a way, when you're taking or driving a profitable ride where Uber/Lyft are making a large margin (like airport-to-downtown rides), you're subsidizing someone who picked-up or waited five minutes for a ride late at night outside some suburban bar. It's the latter kind of trips that most people wouldn't take a taxi for, having previously been made on transit, a personal car, carpooling, or not made at all.

This is a bit like how public transit works. The customers travelling on packed buses/trains in peaks subsidize those on the emptier late-night buses/trains. But remove that late-night service and some of those customers will buy a car and stop taking transit altogether.

As Uber/Lyft are forced to become profitable during a labour shortage, the profitable trips are becoming more expensive (often more than airport taxis) and the less-profitable trips are getting longer wait-times as less is being spent on driver retention (along with higher prices but maybe not as much because of the increased price-sensitivity of those trips).

This model was unsustainable from the start. Even with AVs, their R&D would explode and they’d have to assume the full cost of operating, maintaining, and insuring their fleet, all of which are currently offloaded to their drivers.

1: https://www.insurancejournal.com/news/national/2019/10/31/54... 2: https://investor.lyft.com/news-and-events/news/news-details/... 3: https://www.sec.gov/Archives/edgar/data/1759509/000156459019... (26-27) 4: https://www.carinsurancecomparison.com/taxi-car-insurance/ 5: https://www.reuters.com/article/us-uber-new-york-idUSKBN1YR1...

Sidenote: Am a transit planner and software dev, so researching ridehailing’s pretty interesting/relevant to me.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: