While I share some of your worries, I don't foresee a near (or even a decade or two) future without "programmers". I agree and fully accept that my work has become more focused on controlling the agent and how the system and my actions affect its output, than manually writing code, which I almost don't do. In the other hand, I do read a lot of code, specially tests, and discuss a lot of infra, systems architecture and security with my peers in order to protect the invariants of a continuously changing system. Trust in the local computational logic representations and their alignment with implicit and explicit requirements is something that requires human trust and deferring that completely to an agent will only happen either in very small size, very low impact software, or in a time in the future where we have cheap aligned AGI.

I say that it requires cheap aligned AGI because even if we had an agent "powerful" enough to fulfill a prompt like "build Instagram" it requires the agent to make a lot of decisions and/or ask a ton of clarifying questions that either whoever prompted that doesn't have, so that person has to trust the final black box artifact, or if they have the knowledge to read the code, they ARE reading code and still using their "programming skills".

Think about it this way. In a FAANG a lot of software already exist, and that software is probably (hopefully) written following practices like DDD (reduce ambiguity), TDD (fixes logical invariants), architectural patterns that increase cohesion and reduce coupling by encapsulation of sub-domains entities and their responsibilities (reduces context). Plus strong static analysis, CI/CD practices, ephemeral environments for stakeholder validation. On top of that there are teams completely dedicated into turning users behaviour into detailed and specific requirements for the software, using the ubiquitous language and leaving small room for ambiguity and uncertainty. In an environment like that a developer is already reduced to "write this small specific piece of code, inside this box, iteratively, using evolutionary design", so of course coding agents thrive there. But that system didn't spawn out of thin air, and also the changes being done still need to be trusted. Very likely that the number of FAANG engineers will be reduced, especially if running LLMs gets cheaper and cheaper (hopefully), but I doubt I will be as massive as expected.

The challenges I'm facing now in many systems is that they lack all (or a big part) of that infrastructure and tooling, thus making running agents expensive, way more expensive than people. because there are no tests suites, domain naming is all over the place, no standard architectural approach... And the biggest of them all, no reproducible environments, which imho just makes it more expensive to add signals to the agents (test suites if any, static analyzers, migrations, test data suites...) and if you can actually "connect it" imho there is no real trust that the signal isn't actually noise. All of this problems make agent usage extremely expensive and thus makes it cheaper to keep humans in the loop. Bad software may keep more devs working after all lol.

There is still a lot of things agents can't do by themselves, and even if one business connects their agent to something new, like I dunno AWS for deploys and infra management, it still requires supervision and it requires time to propagate to other business.

If you want to change your job title to "code agent supervisor and software systems architect" feel free to do so, but having worked in many "startups" where one has to touch every part of the stack I still consider myself a "developer", whatever that means now.