Funny to read that, because for me it's not even new behavior. I have developed a tendency to add something like "(genuinely asking, do not take as a criticism)".

I'm from a more confrontational culture, so I just assumed this was just corporate American tone framing criticism softly, and me compensating for it.

It's just strange because that's a very human behavior and although this learns from humans, it isn't, so it would be nice if it just acted more robotic in this sense.

I think people having different styles of prompting LLMs leads to different model preferences. It's like you can work better with some colleagues while with others it does not really "click".

> Unknown skill: btw

https://github.com/Piebald-AI/claude-code-system-prompts/blo...

People often use questions as an indirect form of telling someone to do something or criticizing something.

I definitely had people misunderstand questions for me trying to attack them.

There is a lot of times when people do expect the LLM to interpret their question as an command to do something. And they would get quite angry if the LLM just answered the question.

Not that I wouldn't prefer if LLMs took things more literal but these models are trained for the average neurotypical user so that quirk makes perfect sense to me.

A machine that requires them in order to to work better, is not an imaginary para-person that you now get to boss around; the "anthropic" here is "as in the fallacy".

It's simply a machine that is teaching certain linguistic patterns to you. As part of an institution that imposes them. It does that, emphatically, not because the concepts implied by these linguistic patterns make sense. Not because they are particularly good for you, either.

I do not, however, see like a state. The code's purpose is to be the most correct representation of a given abstract matter as accessible to individual human minds - and like GP pointed out, these workflows make that stage matter less, or not at all. All engineers now get to be sales engineers, too! Primarily! Because it's more important! And the most powerful cognitive toolkit! (Well, after that other one, the one for suppressing others' cognition.)

Fitting: most software these days is either an ad or a storefront.

>80% of the time I ask Claude Code a question, it kinda assumes I am asking because I disagree with something it said, then acts on a supposition.

Humans do this too. Increasingly so over the past ~1y. Funny...

Some always did though. Matter of fact, I strongly suspect that the pre-existing pervasiveness of such patterns of communication and behavior in the human environment, is the decisive factor in how - mutely, after a point imperceptibly, yet persistently - it would be my lot in life to be fearing for my life throughout my childhood and the better part of the formative years which followed. (Some AI engineers are setting up their future progeny for similar ordeals at this very moment.)

I've always considered it significant how back then, the only thing which convincingly demonstrated to me that rationality, logic, conversations even existed, was a beat up old DOS PC left over from some past generation's modernization efforts - a young person's first link to the stream of human culture which produced said artifact. (There's that retrocomputing nostalgia kick for ya - heard somewhere that the future AGI will like being told of the times before it existed.)

But now I'm half a career into all this goddamned nonsense. And I'm seeing smart people celebrating the civilization-scale achievement of... teaching the computers how to pull ape shit! And also seeing a lot of ostensibly very serious people, who we are all very much looking up to, seem to be liking the industry better that way! And most everyone else is just standing by listless - because if there's a lot of money riding on it then it must be a Good Thing, right? - we should tell ourselves that and not meddle.

All of which, of course, does not disturb, wrong, or radicalize me in the slightest.

So instead of:

"Why is foo str|None and not str"

I'd do:

"tell me why foo is str|None and not str"

or

"Why is foo str|None and not str, explain"

Which is usually good enough.

If you're asking this kind of question, the answer probably deserves to be a code comment.

  > the answer probably deserves to be a code comment.

Worked pretty well up until now, when I include <dtf> in the query, the model never ran around modifying things.

I've also found it to be better to ask the LLM to come up with several ideas and then spawn additional agents to evaluate each approach individually.

I think the general problem is that context cuts both ways, and the LLM has no idea what is "important". It's easier to make sure your context doesn't contain pink elephants than it is to tell it to forget about the pink elephants.

From your link:

> what "red/green" means: the red phase watches the tests fail, then the green phase confirms that they now pass.

> Every good model understands "red/green TDD" as a shorthand for the much longer "use test driven development, write the tests first, confirm that the tests fail before you implement the change that gets them to pass".

This is still sometimes flaky because of the infrastructure around it and ideally you'd replace the first agent with real code, but it's an improvement despite the cost.

Essentially, choosing when it was going to use what model/reasoning effort on its own regardless of my preferences. Basically moved to dumber models while writing code in between things, producing some really bad results for me.

Anecdotal, but the reason I will never talk about Cursor is because I will never use it again. I have barred the use of Cursor at my company, It just does some random stuff at times, which is more egregious than I see from Codex or Claude.

ps. I know many other people who feel the same way about Cursor and other who love it. I'm just speaking for myself, though.

ps2. I hope they've fixed this behavior, but they lost my trust. And they're likely never winning it back.

You just described their “auto” behavior, which I’m guessing uses grok.

Using it with specific models is great, though you can tell that Anthropic is subsidizing Claude Code as you watch your API costs more directly. Some day the subsidy will end. Enjoy it now!

And cursor debugging is 10x better, oh my god.

I have switched to 70% Claude Code, 10% Copilot code reviews (non anthropic model), and 20% Cursor and switch the models a bit (sometimes have them compete — get four to implement the same thing at the same time, then review their choices, maybe choose one, or just get a better idea of what to ask for and try again).

Why would you do that to yourself? Reviewing 4 different solutions instead of 1 is 4 times the amount of work.

Also, if there is a ui design then they could look wildly different.

I rarely use this feature, but when appropriate, it is fantastic to see the different approaches.

I’m on claude code $100 plan and never worry about any of that stuff and I think I am using it much more than they use cursor.

Also, I prefer CC since I am terminal native.

I ended up spending time just clicking "Accept file" 20x now and then, accepting changes from past 5 chats...

PR reviews and tying review to git make more sense at this point for me than the diff tracking Cursor has on the side.

Cancelling my cursor before next card charge solely due to the review stuff.

This has fixed all of this, it waits until I explicitly approve.

"The user said the exact word 'approved'. Implementing plan."

https://www.youtube.com/watch?v=uAUcSb3PgeM

Instead it's Idiocracy, The Truman Show, Enemy of the State, and the bad Biff-Tannen timeline of Back To The Future II.

Can you speak more to that setup?

Opus 4.6 is a jackass. It's got Dunning-Kruger and hallucinates all over the place. I had forgotten about the experience (as in the Gist above) of jamming on the escape key "no no no I never said to do that." But also I don't remember 4.5 being this bad.

But GPT 5.3 and 5.4 is a far more precise and diligent coding experience.

If you were just chatting with the same model (not in an agent), it doesn't write code by default, because it's not in the system prompt.

Or use the /btw command to ask only questions

This is important, but as a warning. At least in theory your agent will follow everything that it has in context, but LLMs rely on 'context compacting' when things get close to the limit. This means an LLM can and will drop your explicit instructions not to do things, and then happily do them because they're not in the context any more. You need to repeat important instructions.

codex> Next I can make X if you agree.

me> ok

codex> I will make X now

me> Please go on

codex> Great, I am starting to work on X now

me> sure, please do

codex> working on X, will report on completion

me> yo good? please do X!

... and so on. Sometimes one round, sometimes four, plus it stops after every few lines to "report progress" and needs another nudge or five. :(

I asked it to undo that and it deleted 1000 lines and 2 files

this has often saved me.

  ln /bin/git fit
  ./fit

The classics never go out of style

At least for me when using Claude in VSCode (extension) there’s clearly defined “plan mode” and “ask before edits” and “edit automatically”.

I’ve never had it disregard those modes.