The hitching is compounded for me because I tend to run the agents in squads: the agent I talk to operates a strict no-coding 'producer' mode, it tasks a sub-agent to do the research or coding, then the results go via a file to a critic or review agent; keeps the producer context very minimal and lean. Not convinced it's as necessary as just starting new contexts frequently with Fable etc.

My general rule is that I won't commit code a human hasn't seen/reviewed to production codebases, and I know I won't maintain that rule if I have to read all the slop that gets generated first time round without an AI reviewer pass.

So far my producer skill has survived 4.6 thru fable in succeeding to treat the review/critic output skeptically, as a likely yes-man or team player.

The key is to remember that, as of Fable, the size of the training corpus segment representing people responding to AI-generated content is still relatively tiny. Telling Sonnet 4.6 "this is code an agent produced" has a near decorative effect with no apparent significance, Sonnet 4.8 shows some misgivings, and when I experimented with Fable it seemed to do well at anticipating the kind of slop 4.6 would throw you.

Interestingly, to me, telling Fable that code a previous Fable agent wrote was AI generated seemed to raise some kind of "I'm being benchmarked" flag; expanding the reasoning finds it being evasive and mistrusting; look past the null derefence because this must be a trick question type thing.

That's a 9% reduction, and it doesn't really discuss applicability over longer contexts, different language/language familes/programming, or context/rope length aspects.

Several families - esp Llama and gemma - seem to be easily doom-inclined during expansions (I realize this is a pathological misuse of the tooling, but it's what people do): prompt: "add comments to this file", +1000t file read, [+3k reasoning], +800t edits, +1100t file re-read promoted by tool, prompt:"pep8 format it", [+2kt reasoning], +700t edits, +950t file re-read.

The unmodified/repeating sequences in those file reads, the differences between them, is a honeypot for attention.

I'd non-scientifically concluded for myself that this was tied to an anti-pattern for rope. In the first portion of the context inference needs attention to fall in certain places to produce the correct suggestions for the first round of edits, and somehow largely refocus attention to the subsequent version of the file in the context to correctly apply the subsequent edits, not getting distracted by the tantalizing pattern of repeated sequences and disrupted sequences

Using Gemma4 e2b I can repro this in LM-Studio, and fix it by hand-editing the context so that there's only the latest version of the file being worked on up at the start of the context, or replacing the original reads with something like:

" [tool name='read-file' path=...']... elided, see file.v1.py if you genuinely need to revisit the original state...[/tool] "

The handful of times I've tried this over the last 3 years it hasn't cared to discover file.v1.py didnt exist, limited samples = limited confidence.

Could it be cloud-based? That changes the risk and scale calculus in a way that's going to take a long time to get funding into.

None of the big players involved right now seem to be doing anything to disarm the perception that the LLM does all the work.

I feel like we're at a state fair 180 years ago having just seen an impressive demonstration of small animals momentarily coming back to life, someone in the crowd said 'eternal life' and everyone lost their minds trying to give money to the 'inventor' on the stage who applied the electric current.

Ask some lay people or junior devs how they feel about LLM mistakes, listen for answers about "learning" etc. Do they realize the model doesn't change? The same set of weights and tensors are deployed to every GPU hosting it. If you use a power tool that lets you specify the temperature and seed, it will generate the exact same output time after time.

"But I told it to always speak like a pirate, and it does": No, you signed up to pay for the model to be told to speak like a pirate every time you use it.

There - that's the curtain I'm talking about that you're lifting/tearing. I think momentarily downplaying the potential of LLMs themselves is worth it to expose that.

Elsewhere, I still haven't reviewed the vast majority of AI code I've generated, but all of the AI-generated code I've submitted I did review exhaustively. I have a couple of past roles to thank for drilling some strong code-review strategies and - thus far - have had the willpower to reject an AI generation when I know I can't/won't diligently review.

LLMs do not do anything but generate a token. It's a trivial but critical distinction like RNG vs pRNG. The LLM doesn't learn, it doesn't do backtracking, their output is deterministic.

Not "chatgpt.com"s output, but the LLM powering it; Anthropic aren't customizing a version of Claude's weights/tensors on your inputs, they're adding billable input tokens to the baseline of your subsequent contexts.

Its very financially convenient for Anthropic and OpenAI if people think of the LLM as doing the work, because for a lot of people that conjures a sense of a system that inherently learns and improves.

Even some of the people I've worked with on low-level LLM harnessing tools/systems since early 2023 fall for it and start thinking of the LLM as an AI with the connotations of back-propagation, weight adjustment, ... learning.

The "AI" is in what the harness software does with the inference output and the context it feeds back to it.

It took forever to convince people that quality degrades with context length but then all we got was compaction, there's still huge resistance to harnesses actively curating the context.

A lot of non-devs I've spoken to assumed when their tool said "Now I need to re-read" it was overwriting the 'in memory' copy.

You open aider or code or claude and ask it to fix a bug in file., it reads the entire 8k file, reasons about it (in which it sometimes echoes specific lines of code), and then it "edits the file".

To edit a file, inference currently injects a stream of tokens into the context that your software identifies as a tool call.

[tool name="edit" file="..."] @120,131 - halt_and_catch_fire() + exit_nicely() [/tool]

And frequently the tooling will guide the model to re-read the file, in some pathological cases by prompting the model to generate a tool instruction to do it.

Your context now contains: pre-prompting, your prompt, first file read (8k tokens), reasoning, all the tool calls to make the changes, re-read (8k tokens), conclusory reasoning, tooling prompts llm to describe what has been done, work-done-summary.

Because of the way the underlying LLM works and because of the way the APIs are presented, tools are discouraged from redacting or eliding the original read.

Otherwise, what they'd already be doing is curating the context: read file once, append output from inference/tool calls, and when it's done, replace the original insert of the file.

Having 2 or more disagreeing versions of a significant source file in your context is detrimental to model attention and output quality, and you either see people who get it and manage it, or who wallow in superstition and hand-waving and a near eagerness to pay for "mistakes" that the "model is making" because they believe it is learning, on the fly.

The LLM itself produces one token. Some tool adds that token to the input and runs it again, flogging the horse. Downstream another tool, some kind of harness, tries to control this stream by injecting tokens into the context and then sending it to the inference tool, and then trying to pattern-match the output.

Finally, there you are on CodePorn.yata paying for an agent to generate code, paying for an agent to tell you what's wrong with it, and paying for an agent to make it differently bad, and hopefully move on to the next task.

If it still hasn't dawned on you that this isn't just a bubble, but a snake-oil-bubble-bath, just try to imagine the paradigm shift whereby you go on github.com, assign an issue to an agent, the agent fixes it by rewriting the application in Pascal but a reviewing agent catches that you wanted it to print a measurement in Pascals (pa), and you don't pay for the work or the review, you only pay for work that one or two reviewing agents determine is up to par.

Nobody is going to do that because as soon as they test it they're going to have to do some math that won't make sense without admitting/realizing it's not some near-sentient, AGI rating 0.9 intelligence, it's just a text prediction algorithm that can pull out entire sentences when you use it to infer output on topics it trained on.

"Microgpt's larger cousins using building blocks called tokens representing one or more letters. That's hard to reason about, but essential for building sentences and conversations.

"So we'll just deal with spelling names using the English alphabet. That gives us 26 tokens, one for each letter."

TLDR: I don't understand my native command line, see how lost I got when I tried to do my thing in a different environment.

- Not a unique problem to Windows or even MSVC; He's gonna hate XCode, - Making Python a bootstrap dependency = fail, - Lacks self-awareness to recognize aversion vs avoidance,

My background is distinctly non-Windows, but I survive around Windows so well that people think I'm a Mickeysoft type. And no, I don't use mingw, cygwin, ...

If any of the obstacles this user faced were legitimate, nobody would ever make any money on Windows, including and especially Microsoft - a company whose developers have the same challenges.

I'm being harsh because _mea quondam culpa_ and it's correctable.

Everything this user went thru is the result of aversion instead of avoidance.

To _avoid_ long deep dives into Windows, you need to recognize there is a different vocabulary and a radically different jargon dialect at play.

1. Learn a tiny minimum of Powershell; it's based on the same POSIX spec as bash and zsh, but like Python, Javascript, etc, instead of byte as the fundamental unit, they use objects. So there's less to learn to reach a greater level of convenience than soiling yourself with DOS/CMD/BAT. On Windows, pwsh has a default set of linux-like aliases to minimize the learning required for minimal operability. And never have to type \ instead of / for a directory separator.

2. Microsoft make money from training. To sell their meat-free steak (* ingredient: saw dust), they feed the suits an all-you-can-eat calorie, nutrition, and protein free buffet of documenting everything in great detail and routinely "streamlining" the names and terminology.

Development on Windows is in a different reference frame, but relative to their own reference frames, they're ultimately not all that different.

Approach in your "foreign language" mindset; English alphabet but the words mean different things.

3. What not how. "How do I grep" means you are trying to random access bytes out of a random access character stream. "What's the command to search for text in files?" well, if you're bloody mindedly using cmd, then it's "find".

4. Seriously, learn a little Powershell.

I only approached Powershell hoping to gain material for a #SatansSphincter anti-ms rant while using it as a Rosetta Stone for porting shell scripts in our CI for Windows.

I mean, it is based on the same POSIX spec as sh, bash, and zsh, with a little Perl thrown in. That can't not go horribly, insidiously, 30-rock wrong in the hands of MS, right?

Turned out, it's the same paradigm shift perl/shell users have to make when coming into Python:

from `system("ps | grep hung")` to `"hung" in system("ps")`; from `system("ifconfig -a | sed 's/\<192\.168\.0\./10.0.0./g'")` to `system("ifconfig -a").replace("192.168.0.", "10.0.0.")`

`grep` is a command that applies an assumption to a byte stream, often the output of a command.

In powershell, executing a command is an expression. In the case of a simple command, like "ps", that expression resolves to a String, just like system(...) does in Python.

Learning even a small amount of Powershell is immensely helpful in better understanding your enemy if you're going to have to deal with Windows. The formal names for official things use "verb-singularnoun".

That last part of the convention is the magic: the naming of things on Windows is madness designed to sell certifications, so crazy even MS ultimately had to provide themselves a guide.

There are licensing constraints, IANL but essentially you need a pro+ license on the account if you're going to use it to build commercial software or in a business environment.