On the dark side: the current generation of skilled developers will have absolutely no incentive to train the next generation (it's the other way around), and so in a few years we will have some serious problems.
This might be the biggest challenge arising from modern AI tools. They make half-decent replacements for junior developers, and with the market dynamics of the past 10-15 years, hiring junior developers was already a questionable idea for most businesses. So if hiring good seniors and providing powerful workstations with AI-driven tools becomes SOP then where has the next generation of good seniors come from in 2030 or 2035?
However, so far I don't see much evidence that these tools will pose a credible threat to existing highly skilled and experienced developers. I am bearish on the potential of the current style of LLM-based code generators, because while they do make useful autocomplete++ tools and provide an alternative UI for copying and pasting from Stack Overflow, I see little reason to expect further quantum leaps in capability along the path we've been following. We already have models trained on the largest public bodies of work now and enough memory and processing power to do that training within useful time frames. There's no Stack Overflow Pro where there is 10x as much code written by developers who are 10x as good. And most of the real progress in software development involves significant innovation and/or domain specific knowledge, which are two areas where LLMs will always be limited by the quality and quantity of training data they are based on. No doubt we'll continue to see incremental improvements, and that's useful in itself, but incremental steps rarely add up to more fundamental change.
While posting, did anyone else find this statement from Taylor a bit naive?
In the Autonomous Era of software engineering, the role of a software engineer will likely transform from being the author of computer code to being the operator of a code generating machine.
The guy's apparently a developer by background, so surely he knows what compilers and interpreters are. Almost all software developers have been operators of code generators since somewhere in the middle of the 20th century. The trick has been, and still will be, to make the specification of the behaviour you want clear enough for those code generators to do what you actually want them to do. If only we had a name for writing such a specification...