The "End of Programming" will look a lot like programming (2023)

I fear the most for the hybrid, and that’s happening/coming fast as we speak;

- programmers getting hired and selected by ‘ai’ (resume, interview)

- programmers (their PRs) being checked/reviewed by ‘ai’

- kafkaesque standups where features/bugs are explained by ‘ai’ in a painful loop

- tasks being cut into tiny tasks with time limits by ‘ai’ for human programmers where the ‘ai’ monitors and punishes/awards the human performance

- parts of those tasks being written by the ‘ai’, resulting in alien code being pushed into the project

- ‘ai’ being introduced willy-nilly because it’s cheaper (read; faster to market) than real computer science; why build a parser for formulas? Just put a llm! Why design a robust dsl? Just put a llm!

- etc

This is part of the reality now in places I see already and it will get worse. When LLMs get faster and cheaper, there will be no reason to not add LLMs everywhere and give them some sort of power.

At the moment what the "end of programming" looks like in my experience is:

* Better auto-complete for verbose languages,

* A question/answer workflow significantly smoother than googling it,

* A on tap rookie for 5-15 line pieces of code that don't matter much (it difficult to trust more because quality isn't great),

* An awesome bash one-liner sidekick,

And most of importantly

* A consultable socrates-in-a-box "colleague" that is often useful, but needs to checked.

Most people who say to me that AI will replace programmers are people who haven't built and maintained a software system, and see programmers as interchangeable cogs in a machine. So the author explained in a good way many things that I have been thinking about how AI does not mean the end of programming.

I too have a lot of cool ideas that turn out to be much harder to make than to talk about. The very best case performance of code assistance tools as they currently exist seems to be that they moderately increase the productivity of developers who know what they want and know enough to check the autocompleted work. As a ML researcher who's watched the progress of both code generation and natural language processing for about 10 years in earnest, this is a crazy awesome result, a breakthrough in the field that's very laudable (except for all the shady data provenance sleight of hand that allowed the companies spearheading this effort to make progress, but that's been talked about by people who know a lot more about applicable law than I do and I won't do it justice, and it's tangential in a discussion of what's possible). But there is no result so impressive that business people in the midst of a tech hype wave won't apply some added bullshit to in order to fundraise, and "the end of programming" seems more like that than a realistic assessment of the capabilities of current systems, or even a plausible result of merely incremental progress on them

It will happen someday. Still decades away. No true learning in the current LLMs just plagiarism so far to get better. I work at a place that is trying to use LLM to do a thing. just hired two humans to double check the work. They now do almost all of the work ...

The end of programming will be no programming at all. First AIs will do the things that are necessary without someone telling them. If there are still companies, e.g. this means sending emails to customers (who have AIs that are reading their emails and acting on them ;-) to sell more things, create APIs or websites on their own, hire other people (AIs) to do things they can't do (regulation, other country, etc.).

For the mid future, it's like Star Trek: "Computer give me the customers that perform best" - from a data lake, no data warehouse, no CRM code, no web frontend. No programmers, just users.

For the near future, developers will become managers. Instead of hiring and managing people, they will select and manage different AIs for different tasks. See what those are doing, give them feedback (just like a manager would to developers), change the prompt (like a manager would clarify a task), give them data, grow them (again just like a people manager today).

Why bother disputing claims about AI made by the CEO of a new AI startup. They are obviously going to be throwing lofty statements around about its capabilities.

Everyone agrees that catching errors in the design phase is far superior to catching them in implementation or testing phases.

So why are requirements often mentioned only in passing ?

Don't they deserve some intellectual TLC ? Writing good requirements is at least as challenging as writing good laws. And then, as the article suggests, an AI can kind of fill in the missing bits if it has good cultural context.

There's many good tools now for formulating and managing requirements. Why do I not see papers about how LLMs benefit from them ?

Wherever we have enough redundancy that we have to tell a tool to write out more code for us within certain parameters, is somewhere we have yet to create the right high-level abstractions. This remains a problem even after LLMs do some of the work for us.

The whole point of making more expressive languages and APIs is that we should be able to solve large problems with only the required amount of specificity in each instance, leaving only the code that is the right level of detail for someone to be able to read, understand, and maintain in future.

In the ideal extreme, it shouldn't be any more difficult or tedious to write the code to solve a problem as it would to give the LLM a description of the solution -- if the description was precise and unambiguous then code of similar length should have been able to encode the same. There are many ways that modern programming continues to fall short of this, and that's a problem we should still be working on instead of giving up on.

Even if writing and maintaining code are completely obsoleted by LLMs, we're still going to have to demand humans in the loop on review and testing before we risk life and limb deploying that code. Code still has to be understandable by humans, so it still has to be written with appropriate abstractions to make review accurate and tractable.

We still have the same incentives to want expressive languages and APIs. If we give up on that and bank on LLM generation instead, we'll stop making progress on expressiveness and be stuck with a stale snapshot of today's programming language evolution, that LLMs are limited to writing and humans are limited to reading forever. Without direct disincentive for writing and maintaining that redundant volume of code, the inevitable review will suffer the most.

Imho programming is just a medium of reasoning. In that vein I find arguments like this odd.

As I believe they day there is no more need for humans to be involved in any programme , is the day there is no more need for any reasoning by humans. Not something that seems likely to me.

Then again this article comes from someone developing AIs… how could that not be lofty…

IMO the real value of AI for programming will be in helping you read code not write code. I want to hover over a function call and it can just tell me what it does like a comment blurb above the function should.

Software development requires certain qualities from a programmer which AI can't attain before becoming human: personality and consistency. Personality is shaped by lifelong experiences mostly irrelevant to programming itself. Personality dictates the experience you want for the users. To be able to do that, you need to know the users, you need to understand how a human thinks, functions, and understands things.

Consistency is an artistic element shaped culturally. Again, you need to be exposed to cultural elements for a long time, and more importantly, develop an understanding of them.

I think it's very hard to train AI on these two fronts, and that's why we'll be needing programmers for a long time. AI will keep doing the mundane tasks for us though, thankfully!

The end of programming will be the end of code.

Code exists solely for humans to interface with machine language. If code is involved at all in any solution, it's a concession to humans.

An AI with the power to build software from some definition doesn't need to write code. Else it simply does not have the power to write software alone.

Seeing this stuff is so mindboggling to me every time. I use GPT4 EXTENSIVELY and it actually sucks so bad for anything complex. How are these takes still coming out on repeat? I've been using it for a YEAR

The havoc that ai will cause on education will likely, in the near term, make programmers even more sought after, not less.

Currently some programmers, and with time more, have to write, integrate and debug LLMs, hence for the programming to end, other LLMs would have to be able to do so, too. LLMs successfully modifying other LLMs is, like, singularity. In other words, the moment programming ends is the same moment we all are going to die.

I have a hard time believing that AI models will become the environments that software runs in, because they're not performant, reliable or maintainable the way Node, JVM, binaries, web browsers etc are. Or standards compliant. Nor do they have the same kind of access to the hardware these environments have.

And short of software running directly on models, I don't see how programming is going to be completely automated away from humans.

And even if you can make models competitive with traditional software environments, I don't forsee managers and CEOs spending their days prompting the AIs to produce the right kind of code their customers don't know they need. They will pay prompt programmers to do that instead.

We just need to train an LLM how to make an LLM that can make even better LLMs then rinse and repeat. Nothing beats working yourself out of a job.

The article gave me a deja-vu about the no-code wave a few years back and an excellent article I read on the subject [1]

> The logic doesn’t go away. Just because a decision is embedded into the wiring of a Zapier rule doesn’t remove any of the burden of maintenance / correctness.

Of course, AI is a lot more powerful than no-code, but the "End of Programming" suffers from the same delusion. If AI can reliably make every decision around engineering, design, and product, it would be capable of doing every task in the world. It's surprising that so many engineers believe writing things in plain text would obviate the need to learn programming.

[1]: https://www.alexhudson.com/2020/01/13/the-no-code-delusion/

„In general, a lot of the AI takes I see assert that AI will be able to assume the entire _responsibility_ for a given task for a person, and implicitly assume that the person’s _accountability_ for the task will just sort of…evaporate?“

This is a key insight.

I think it is obvious that most programming tasks will be replaced by frameworks or whatever we call it. It is not about AI but about zillions of developer reinventing the wheel and having a lof of redundancy. Once specific framework or tools is accepted (e.g. boilerplate generation) the need for more developers hours is decreased. If this is not happenning now is because there are few good crafted frameworms and/or creating them make a lot of development tools (e.g. Microsoft) irrelevant.

There will always be problems that cannot be automated but they will ve minimal and very specific.

History teaches us that "business people" want to "reduce cost" so they will try anything to achieve cost savings. They see the people in the software creation process as necessary evils, or uh, costs, instead of integral to the process of translating vague, usually English, business words into software.

4GLs (Visual Basic, Delphi) and Low/No Code are promised as ways to have "business analysts" or "citizen developers", i.e. lower cost resources, do the work. To be honest this is successful enough to keep selling the idea and products for a period of time. In reality most of the successful work in these areas are done by developers or people that could be developers.

Code generation by LLM is the same thing. Yes, it has value. In the hands of a motivated software developer it will do great things. In the hands of someone that wants to take a short cut because "lower cost" it will fail way more often than it will succeed.

That said, AI and code generation are here to stay and software developers should get used to using them.

I've been playing with open interpreter a bit, and to see a lot of the things I do that I take for granted written out in code made me realize how much handling of computers I take for granted. for example, I was editing files via open interpreter, and needed to add a header to some files. I, of course, got it wrong the first time and had to iterate on it a bit. As a human, editing the header is trivial, but for the computer to do it for me, it has to write a program to parse the file with a regexp of something, and while it manages to do that, its limitations become apparent, compared to a human. so the end of programming does look a lot like programming. the computer does what you tell it, not what you were thinking.

This seems like a long version of my favourite commitstrip: https://www.commitstrip.com/en/2016/08/25/a-very-comprehensi...

Predictions about a future technology that may exist at some point are almost always dumb.

I don’t see programmers going away because of the current wave of AI, I don’t know about what is coming next, but for sure the current hype is very bubbly and also dumb.

Let's face reality here: In the end, AI and robots will be able to do anything better than what we humans can do. That is the harsh reality that everyone will need to accept.

What happens in the mean time will be unclear, but I think most of us still make the false assumption that LLM's are 'robots', while in fact it already became clear that emotional blackmail works on them. AI's might not be as rational and cold as we might expect.

So in the end, I don't see how humans will be able to keep the upper hand on:

- doing user interviews

- analyzing user behaviors

- optimizing business decisions

- writing code

- tracking down issues

The "end of programming" is something which happens over and over through one's programming career. You get used to it.

"End of Programming" will look like a Mag-7 interview: [program design] + [leetcode].

> One of my problems with GitHub Copilot (and similar systems) is that you still own the resulting code, and it does not provide any path to gaining confidence that it has given you a correct implementation, despite you owning the correctness of the code it generates

I don’t really see the issue? You take ownership with code review and testing. It’s the same thing you would do if you copied an example that someone gave you and then modified it. The original author isn’t responsible.

(If you don’t understand what the code does, throw it out and find something else.)

I've been hearing about 'The End of Programming" ever since I entered the field back in 1979.

It was bullshit then. It is bullshit now.

You should think of this AI instance as just one more advanced programming language, that's all. It'll be no different from having to learn to program in Java, or in Rust, or in C, or in whatever.

But mark my words, there'll be some poor programmer who will have to do the work of programming.

For a long time you've been able to just describe what you need to a dev shop in India and have your program built on the cheap. And yet, most companies don't do that...

The webcrap industry is mostly doing rather uniform things. That can be automated. Much of it already is. Small business sites are mostly machine generated already.

Matt Welsh is an idiot, there saved you 5 mins reading the article.

The author's stance also used to be my stance for a long time. Then, earlier this week, I tried out AutoGPT/evo.ninja (which uses GPT-4 under the hood) and told it to "Write me a snake game in HTML, CSS and JavaScript" and, voilà, it wrote me a game that I could open in my browser and it worked perfectly out of the box.

I also tried this with Tic Tac Toe – it didn't work at first due to a bug in the CSS but the agent was able to fix that bug in the second round. It knew the context, knew the files it had created in the first round, and knew what I was talking about when I said "the Xs and Os are not visible", etc.

So, yes, program specs might still be needed in the beginning, when a piece of software gets written from scratch. But AI will often just fill in missing steps, and once the code has been written, the AI will simply iterate on it, and so the code will take on the role of the spec, just like it does nowadays. No need for the product manager to write detailed specs anymore.

All in all, I think the second direction mentioned in the article (AI becoming a full-blown software developer) is a lot more likely than the author thinks.