I think this is a sad vision of the future not because a lot of programmers will be forced to do something else, but because it seems like this represents a fundamental failure for formal methods. We're hurtling towards a world where we automatically generate low-quality, buggy code, produced by stochastic parrots who mimic code written in possibly a different era by humans tackling different problems.

Forget about being employed producing software in a world where these are the norms, I don't think I'd want to be a software _user_.

I'd love for programming to be higher level and accessible, but I wish the process were:

- write a _specification_ that describes functionality, invariants, etc

- generate signatures compatible with that specification

- interactively seek implementation-relevant information from the designer, e.g.

  - "I see Users can have an unbounded collection of Bars, which can each reference an unbounded number of Wugs. How many Bars do you suppose a typical User would have? How many Wugs per Bar and how many Bars will reference each Wug? How large is a Wug typically?"

  - "Which of these DB queries do you expect to be run most/least frequently?"

  - "This API method allows for pagination. How often do you expect a user to page beyond k?"

- generate tests

- generate code aligning with signatures, _and which cause tests to pass_ (i.e. program synthesis from examples)

- static analysis / abstract interpretation / model checking to confirm that some invariants are respected

- explicitly reporting which invariants or properties were not able to be confirmed automatically which a human may need to confirm via an ad-hoc analysis

Software is one of the domains where we can actually do a lot of sophisticated automated reasoning, but the current trend of ML code generation as text completion ignores basically all of that, and this seems like a giant waste.