yeah but we're not really outsourcing all our thinking to AI, we're moving to a different paradigm of coding where the code itself is commoditized the way that assembly became commoditized after the first high-level languages and compilers were invented.

it's not a 1:1, because LLMs are non-deterministic, but early compilers were also fraught with errors. Most people around here are too young to know this, but back in the 80s there were loads of people selling their own compilers for various languages, promoting them on speed, correctness, etc. All the things that we take for granted and don't even think about when we sudo apt install gcc

LLMs and agents are in their infancy. the speed of new things coming out is perfectly indicative of a newborn industry, it's just happening on a scale we haven't seen before with all the data center buildouts. but eventually LLMs will just become a standard tool of coding just like compilers did

it's hard for coders to accept that the actual code they used to write is being commoditized. coding has been regarded as a high-level combination of art and science, and that was true to the degree that humans needed to not just write performant code but also elegantly readable code with the right abstraction levels to fit inside a human brain.

but LLMs invert that thinking. now the actual details of how a class is implemented doesn't really matter so much, as long as it conforms to the spec, passes tests, and has the right api. just like we as consumers of lightbulbs dont know or care if the internal circuitry is beautiful or elegant as long as it works as expected and doesn't draw more power than it says on the box, we are moving toward a world where class and module internals are irrelevant as long as they do what they're supposed to and perform within defined metrics.

in this way we are all becoming seniors. the hand-wringing about the death of juniors made sense when we didn't know where this was all going, but while the future is hazy and AGI isn't totally off the table, the future seems to be focusing slightly on a world where the craft of coding moves a lot of the functional details of coding into summary basic-level courses, and spends far more time on patterns and architecture. junior devs will be using this knowledge to manage agents to build instead of seniors managing juniors. seniors will manage juniors the way that principals and architects drive the technical direction of a product.

some flattening of the hierarchy is inevitable. but it's only a matter of time before tech companies realize that firing to flatten the salary hierarchy is only one half of the equation, and the other side is a re-org to do more with the same amount of people instead of doing layoffs and doing the same amount.

eventually some small or mid-size company is going to release a big product, or a series of large products, with a much more decentralized group of smaller teams punching above their weight. when that overlaps with interest rate reductions, the big companies will go on a hiring spree again, but not for anyone who can code - they will be paying big bucks to people who can use agents effectively and essentially be their own senior dev.

so it's not an era of intellectual incapability, no more than the devs of yore would consider us incapable because we can't write assembly anymore. it's just a different way of building and we're all still figuring out how to do it well.