Source-inline display of auto watch expressions, computed by determining which addresses are read from / written to by a particular range of instructions, and mapping that back to variables via location info within debug into.

Human oversight is fundamentally necessary for producing anything consumed by humans. In fact, anything consumed by an entity with a value system must inherently be produced by an entity *with a similar value system* (this is why trade can extend across some national/cultural boundaries but not all). Obviously some value structures are more relevant in some domains than others—trading bare necessities (energy, food, shelter) is easier than complex value-related products. “Intelligence” sufficient to replace human work makes this doubly true, because specific value structures (e.g. creating goods that are not to the detriment of their consumer) are not intrinsic to intelligence nor can they be explicitly programmed. Furthermore, given that software is (for all intents and purposes) an ~infinite space, human demand can expand into that space arbitrarily, requiring more and more software work. Every serious programmer knows the feeling that there is effectively an unbounded amount of work to do, and projects to investigate, almost certainly until they get bored or die. Thus, even with improved efficiency and fewer humans needed to do oversight on any one project, you’d still expect a larger number of human overseers in the end. In practice, given that the so-called “intelligence” is extremely limited, it’s capable of producing a small fraction of that total space. Thus, you’d expect supply for that fraction to rapidly increase, despite a fixed limit on demand for it—demand will be magnified in areas with much less supply, which require greater human oversight and authorship.

For any given desired computational outcome, there is some sequence of bits which encodes that. These bits of signal (of the desired outcome) can be intermixed with bits of noise. The reason why these LLM-generated codebases by default have so many obviously useless lines of code is that, for any given generative step, the LLM’s job is to package up the few signal bits (from the prompt) into a plausible presentation of other bits, which may or may not be noise. If they are extra signal (because they can be statistically inferred from the other signal bits), then that’s a win, but there’s a much higher probability that they’re actually just noise. This is why every AI generated tweet, article, or indeed code snippet contains drastically more fluff (noise) than what a focused person with reasonably good instincts for compression would produce. So, in order to actually accomplish anything (without extreme vetting, compression, and modification of generated code), the “programmer” (prompter) needs to continuously generate more code to obtain the next signal bit they wanted, at the expense of many, many more bits of noise. The result is often ~100x if not ~1000x more code than was needed, which is impossible to hand-edit, comprehensively understand, or compress. Layers upon layers of statically average nonsense, wrapping the few bits of utility you actually wanted.