In which I describe some pretty-OK analogies for using LLMs as (essentially) disposable-code generators.
Possibly in ascending order from less appropriate/technical, to moreso.
-
Transpilers: Typescript -> Javascript
TypeScript "compiles to" JavaScript. I don't know of any sane person who diligently inspects the emitted Javascript...
TS is by far not the only JavaScript "compiler", although it is probably the most successful/best-known (tbh, it's technically a superset of JS): Wikipedia shows
- AtScript
- Babel
- ClojureScript
- CoffeeScript
- Dart
- Elm
- Emscripten
- Google Closure Compiler
- Google Web Toolkit
- Haxe
- LiveScript
- Morfik
- Nim
- Opa
- PureScript
- Reason
- WebSharper
TL;DR - it's downright commonplace in the JS world to not know what one's actual running code looks like.
-
HTML "arts and crafts" vs generators
Does anyone (aside from total cranks) really do "this website was hand-coded in HTML using 'vim'" etc? (you know who you are 😬).
There's a teensy matchstick-man in here, given that the web is mostly JS+CSS these days, but even so...
The JS is generating and manipulating HTML, and the CSS is styling it literally invisibly - the only way to do what CSS does "manually" is by using a 1 to 10 (probably more like 100) ratio of lines of CSS to hand-styled HTML, and some things (CSS animations) simply aren't possible with HTML.
-
asm -> c (compiler trust)
A long, LONG time ago, greybeards/neckbeards spoke Assembler. Then came the c programming language. They were sore perplexed. There was no way to see an Assembler equivalent! This "c compiler" thing made some magickal transformation directly into CPU opcodes (technically hexadecimal numbers). "How can we possibly trust this, without understanding everything about the compiler?!"
I have had push-back on using this analogy with coding agents. CS-degreed people from The Before Times (before ChatGPT) will assert that there are PLENTY (🤨?!) of people who understand compilers at a very deep level.
I'll grant that that set is relatively large, especially compared to the set of humans who deeply understand exactly what LLMs do internally ("zero", tbh), but I assert (I think quite reasonably) that, compared to the set of persons who only use compilers day-to-day, that set is vanishingly small.
In any case, compilers are essentially "invisible technology" now.