electric_toucan

It doesn’t matter how exactly GCC works, as long as the behavior is deterministic and consistent (GCC is likely maintaining backwards compatibility between versions, so the behavior of your code likely hasn’t changed). In that case, you can reason about the behavior you need and write your code appropriately.

In the case of LLMs, the behavior is non-deterministic and inconsistent. If I don’t explain how handle an edge case or give a performance constraint, the LLM will still produce code and may do so in different ways, handling edge cases differently and with different performance characteristics. I can’t reason about how the LLM will fill in those gaps, it’s “random.”

Maybe you don’t care about how the LLM handles those edge cases or handles performance, but that’s different than a deterministic abstraction whose implementation details you don’t care about, but whose logic and performance is deterministic and consistent

Compilers like GCC are deterministic and the source code already fully defines the behavior. LLMs are non-deterministic and will accept ambiguity, filling in details where you haven’t. These sorts of comparisons aren’t really fair.

In the case of writing, it’s like hiring someone to write a book for you vs. hiring someone to translate a book you wrote into another language. In the first case, you didn’t really define the message for readers, whereas in the second case you did, and the translator is converting that same message for another audience to consume.

I think a lot of the discourse around AI is imprecise, but you’ve done a good job of clarifying. AI is also changing the definition of some terms, so debates are happening where people use the same words, but mean very different things.

Some people say “coding” to mean the process of converting a well-defined plan (requirements, architecture, everything) into executable code. Others use “coding” to also include all the small decisions you make when writing code, like the abstractions you build and how you handle ambiguous requirements.

AI has decoupled “typing the code” from “making the decisions about what to type” because AI can generate code from very ambiguous prompts. So “coding was always the easy part” is meant to use the second definition and emphasize that you may be able to generate code, but having good decisions embedded in the code is still a difficult, unsolved problem with AI.

There are also different definitions of “what to build” with some people meaning the technical details, as you’ve called out, and others (I think especially more business/product roles) meaning the functional requirements of the system.

Sandboxing is useful but usually not a replacement for permission prompts. If you give it network access, it could still run destructive commands against allowed domains, for example

When I want advice, I’ve found it useful to tell the model that someone else came up with the ideas we’re discussing, not me. That pushes the model away from sycophancy, and better calls out the risks. Sometimes it goes too far in shutting down the idea no matter what, but I think it’s easier to critically evaluate critiques than to step back from the model praising everything you say

I think disliking cyclists is the core position for these people. They don’t want cyclists in the road and they don’t want to pay for infrastructure for cyclists, like bike lanes.