A path forward

I do not remember where exactly I read it among the many resources I've consumed related to large language models starting early 2023, but among a few other things, the skills required for programming, which were implicit, started being more explicit, beginning with the ubiquitous question: if LLMs can code, what would SWEs do ?

This essentially proved to be the wedge that separated those who saw LLMs replacing them, and those who saw them as tools to realise their dream projects. Alas, reality set-in eventually, and the former could not be replaced completely, who now use them to write more or less sloppy code, and the latter only got boilerplates to start their projects with.

But as we slowly converge towards LLMs being (not AI), rather efficient congnizant machines which are great at converting intent to code, we are left with a question: if learning to code is becoming irrelevant, what do we learn ?

The answer lies in recognising the overall meta-trend of technology (for a lack of a better word. I basically mean, a sub-trend or sorts?), which is the explicitization of more abstract ideas into tangile code. This trend shows up in technology and AI research, but then again, the holy grail of tech (or computers but whatever) is AI. This trend shows itself when we look at the evolution of programming languages and the history of computation, alongside strides made in AI research. More precisely: Our initial goals always evolve from problem solving to optimizing tool efficiency, which in turn helps us solve more complex/abstract problems, and so on.

(A quick example: modern front-end is hard to imagine without frameworks like React, wherein modern developers might feel writing vanila html/css/js almost alien. This might seem atrocious to developers a few years ago, and the level of abstractions go deep. Browser engineering, Operating systems, hardware engineering etc ... A problem in React would be intractable to even conceive at the browser level. More abstracted tools help us solve more abstract problems.)

(Another side note: it's generally a saying that to be a good developer is to be familiar with one level up an abstraction as well as one level down)

Now getting to the main point: it is more advantageous than ever to understand the abstractions which are being explored on the very theoretical limits of computer science (or rather all the sciences). (See my other piece on explicitization of theories), wherein the goal should be to acquire an ability to dictate intent such that we can either extend said theoretical limits or be able to make the LLMs emit tangible code to express abstract concepts and as a consequence be able to solve more abstract problems, with real world impact.