My expertise is in designing, understanding, and debugging complex systems. I will just apply my expertise to the AI.

Another angle: just think of how many mom and pop shops are still contracting out to get web sites, and not getting what we consider quality. Now maybe you're going to see a larger and larger gap between F500 companies and the rest (surely you do already), but playing out the consequences is a long and interesting story.

> coding without AI will feel as antiquated and inefficient [...]. And resistance is futile because markets will punish those who refuse.

Fortunately, the "punishment" by the market will just be reduced salaries. Move out of the Bay Area now. :)

> And coding is just one of the many applications where AI an replace brains.

And writing about those is interesting. With the development of DALL-E (etc), I would say coding isn't even the primary interesting application. (If "it's not AI", whatever... that's not the point.) Or not yet.

They used to, 10 to 15 years ago. Now they just hire a SMM specialist to set up their Instagram account. Why would they bother with a website?

That might be true for you and me but imagine somebody fresh out from university - the job market for junior devs will totally collapse in the near-near future. And then what? Where do the mid-level engineers come from if there are no* junior roles? Where will the future senior level engineers come from? We're certainly living in interesting times..

*: There will be some artisanal companies who will pride themselves in having hand-written, AI-free code. These companies will be a minority and 90% of junior level software development jobs will disappear in no time.

The role of junior software developers will not be needed, just as we don’t need people doing multiplication by hand.

The key here is what are you taking responsibilities and decisions for. Senior engineers take decisions which consequences will be apparent in a year or two. If productivity increases to the point where features that take months to deliver take days, the decisions made _currently_ by senior engineers can be taken by fresh graduates.

There’re still going to be senior roles, but their scope will be much bigger and expertise sought will be different than what senior engineers do currently. No one will hire a senior engineer just because they can architect and deliver a scalable SaaS product on a short timeline.

Engineers who learn and adapt will be fine. Engineers who dropped learning the moment they graduated from college… not so much.

I suspect SWE may trend toward other ailing fields like law with individual devs working on entire 'cases' and it being very competitive; rather than the recent "20min Js tutorial on YT to SF startup" industry.

Retaining the profits and placing them back as UBI could work.... although if we do that, the politicians will just find a tax or another project that needs the money before giving it to people.

That is called socialism. I don't mind socialism and state owned enterprises as long as the force of market competition is still at play. That is the reason state owned enterprises don't suck in China. They have multiple SOEs within the same fields like car manufacturing and telecommunication competing against each other.

Inferior to machines at almost everything? Most jobs are safe, look at the 25 most common jobs in the US - cashier, food preparation worker, stocking associate, laborer, janitor, construction worker, bookkeeper, server, medical assistant, bartender, administrative assistant, marketing specialist, police officer, electrician, mechanic, etc.

In theory, if all developers are replaced, they should be able to find a different job. The problem is that the different job may have lower pay and status.

There's really no need for UBI.

Automating all the other stuff that's left on the table.

The only reason why they haven't already been replaced is because humans can be exceptionally cheap. Much easier to hire somebody to sit at a desk for $10/hour doing repetitive tasks than spend millions implementing systems across the board to do what they do (for now).

So perhaps in the medium future humans will be "stuck" doing only physical tasks, while AIs take over everything that can be done virtually.

I will say though, that for a lot of those jobs human-replicating robotics isn't even necessary. We exaggerate the difficulty required because we're still assuming that the exact current system should stay in place. However, sticking within food preparation example, look at those elaborate cake vending machines found primarily in asian countries. There really isn't a reason why McDonalds can't do the same for some of their offerings, after all most of their stuff is frozen anyways.

Not that I'm against it. just call it for what it is.

I don't agree with "we will have full control over it." I'm more concerned about how much control it will have over us.

Man, that is some food for thought. Beautifully put.

We've always progressed to needing fewer developers to do what we currently do. Companies like Squarespace, Shopify, AWS, etc have allowed people to do more with less. Long gone are the days an artist would hire a developer to build them a website they could host a portfolio on.

But growth has filled in the voids with more ambitious work.

It's daunting, but you can also look at this from the opposite perspective. Why work for someone on a 5 person team, when you can try and run the same business with 1 person (i.e. you).

The people who should be afraid are actually those that run companies like Meta and Twitter. Better developer productivity means competitors can chomp at their heels with much smaller teams.

A Chat-GPT4 model will generate unit tests? Hallelujah! I hate writing tests! Yay!

Except how do you know it's generating the right tests? Can it explain its reasoning? Unit tests are a weak form of automated specification. Why are we inferring our specifications from examples to begin with? Who is going to walk through the reasoning and verify these are the right tests and make sense and specify the correct properties? Can Chat-GPT discover properties and prove theorems?

We used to do this in code review where humans could explain their reasoning. Now we have Chat-GPT4 which will give you a plausible-sounding answer that is completely wrong and makes no sense. We have to read every line it generates and make sure it contains no errors, is properly specified, makes sense, etc... something we're extremely ill-equipped to do.

The problem of programming, for me, hasn't been about how much code I write or how quickly I write it. It has always been about solving the right problems with elegant solutions. The code itself is an artifact of the real work.

CoPilot just doesn't really help here. It doesn't understand specifications and doesn't do any reasoning. It can't take a specification, generate a program, discover new abstractions that make the solution more elegant, and explain its reasoning. It can generate a heck of a lot of code though! Wow! Is it the right code? Maybe!

But that's what we get with humans, right? No!

Humans can explain their reasoning.

I just don't see this as being a barrier for too long. Not when more companies opt into training data internally.

But in general I agree with the basic premise of what you say in that, it will eventually happen.

> But that's what we get with humans, right? No!

> Humans can explain their reasoning.

can you explain your reasoning as to why a language model would never be able to match a human's ability to explain its reasoning?

i've met a lot of humans that are quite bad at this, and i will likely never know for sure why they wrote the unit tests that they wrote unless i rewrite those tests to myself.

but if you have them explain their reasoning enough, and if that reasoning is plausible enough, and if the relationship between that reasoning and what they did is strong enough, consistently enough — you start to trust them.

you don't trust gpt4 to write code for you. which makes sense. but that doesn't mean as much as you think it means, i think.

It’s a language model, not a reasoning model. A lot of its training data happens to be logical, so it sounds logical, but it’s still just acting on probability. Thinking it’s “explaining” anything it produces is a mistake.

Sure, it can be flat out wrong, but it is always eminently readable. Self-documentating code with clean comments, far above the standard I see on average human code. That's about as good as "explaining it's reasoning" as you get.

Also, you can literally ask chatGPT to explain the code, line by the line, and it will. So there's that.

Is it ready now? Certainly not if it will be expected to the do the entire job of a SWE. But it is already extremely useful, especially to less experienced devs as both a production for specific tasks and as learning tool. And it will only get better.

I would give an answer from ChatGPT where it confidently told me that I should evaluate an object detection model by ranking matches using negative IoU (and it indeed generated code to do it and gave a confident explanation of how this was normal in computer vision, but it was completely backwards).

So you're not alone. You can even point to the plethora of "find the undefined behaviour," tests: humans are really bad at finding errors in code.

In my own project I've got it generating solutions to errors, and if possible, it also generates simple unit tests to validate the fix. What I haven't implemented yet (and likely won't, because Copilot does it now) but I have tested is generating a pull request describing the fix, why it works, and the same for the tests.

> Now we have Chat-GPT4 which will give you a plausible-sounding answer that is completely wrong and makes no sense.

With limited scopes, it works quite well. For example, something fails because a DOM reference is undefined in a React component. GPT will add a condition to assert that the reference is present, then generate a simple test which mounts the component with stubbed references that are present or undefined using jsdom. The tests makes sense. A quick scan shows they're sensible, and upon running them, they do work.

I began adding a recursive feature which would automatically debug issues with its own solutions, but it can get a little weird in some cases. Likely due to bad prompting – I haven't dedicated enough time to it. But it can also make it so tests with errors are revised and corrected so they will at least run.

All of that with a coherent explanation of what was changed, why, tests, and why they assert the fix is valid.

Is it perfect? No. Could it be useful? Absolutely. I'm a little sad Copilot makes my project redundant because it was actually very exciting to build. There is real potential here. I started the project in order to learn and validate GPT, and I'm very convinced it has genuine utility and massive potential.

> CoPilot just doesn't really help here. It doesn't understand specifications and doesn't do any reasoning. It can't take a specification, generate a program, discover new abstractions that make the solution more elegant, and explain its reasoning. It can generate a heck of a lot of code though! Wow! Is it the right code? Maybe!

I think the key is limited scopes. Like with the React component example, the solution is small, easy to reason about, and tedious to resolve yourself. I understand why it doesn't work, I get the error, and spinning up an entire branch and PR to clean up the mistake is a bad use of my time. I don't want Copilot/AI to work magic, but I'm okay with it resolving minor mistakes and misuses of languages and libraries here and there.

I do think it will grow from here to do more and actually be good at it, though.

Copilot (the existing gpt-3 one) definitely helps at writing unit tests. Yeah, sometimes it doesn't nail it, but one thing it can do reliably is to repeat a pattern, and I don't know about you, but my unit tests tend to repeat the same pattern (with some tweaks to test this-or-that-case). Quite often it infers the correct change from the name I gave the test method, but even if it doesn't it'll write a 90% correct case for me. I imagine the GPT-4 version will do more of the same with better results.

It cannot replace reasoning, but it can augment it (by suggesting patterns and implementations from its latent space that I hadn't thought of), and worst case it can replace quite a bit of typing.

Long-term, it remains to be seen how far bigger/better/stronger LLMs can push the illusion of rationality. In many fields, they may be able to simply build their ability to pattern-match to beyond some threshold of usefulness. Perhaps (some subset of) programming will be one of them.

Isn't this something we've built into every modern language(and arguably the entire point of languages)? If you have multiple pieces of code that share code with tweaks(to test this or that case for example), shouldn't you parameterize the bulk of the code instead of getting autocomplete to parameterize it for you and dump it into your source file multiple times?

By the same token, often it takes a stab at generating code based on something's name (plus whatever context it's looking at) and does a better job than the IDE could, because the IDE just sees datatypes and code structure. It really does feel like a complementary tool.

Yes, actually, it can.

When my team gets crunched, it's not usually because we can't write the code fast enough. It's because of product requirements (changing, needing to be fleshed out, being unrealistic, being understood properly by QA, being adapted to the realities of reasonable code, not existing, etc.).

On top of that, needing fewer workers to do X work !== getting X work done cheaper. Quite often, it means getting 2X, 3X, 10X work done. As an overall trend, modern society has increased worker productivity dramatically over the last few decades, yet many work as many or more hours than they used to. We could get the same results with fewer workers, or we could make them work more. We know what 99% of CEOs will choose.

Of course, maybe it will reduce developer jobs. I'm not ruling that out entirely. But when (not if) we create an alien intelligence that can wipe out our industry, we may have bigger concerns than steady employment.

So that really I'm writing with and about AI[0] to get the best of my technical and literary backgrounds, and to reach good audiences.

Meanwhile writing is safer because contrary to code, a personality and a personal life will ever be valued in flesh and blood writers. And how could an AI, ever write love poems with a soul if it has not opportunities for falling desperately in love, suffering, changing wholesale because of an experience like that? It could emulate it. But readers want to read real sufferers, mortals who get old and lose their looks and so forth, not little gods of sillicon.

[0]: https://generativereview.substack.com/p/the-generative-revie...

However, GPT 4, which is amazing but not able to do what a SWE does, is already making concept artists, voice actors and content marketers obsolete. The arts are far more susceptible to this technology.

Anyone who thinks SWE is generating Python snippets doesn't really understand the role.

I don't really see that it's sad. Imagine truly democratized programming. Not like how the refrigerator did the ice man, but in how Youtube and smartphone cameras did video production. A rising tide that lifts all boats and can give absolutely anyone a taste of what they could achieve with a little effort.

There might be more programmers out of this developments than before. It just will lower the barrier of entry, and increase productivity. Like most tools

Funny enough your observation of

> "There are more accountants now than then."

could be extrapolated from in two ways

The optimistic perspective might suppose technological development gives rise to new marketplace adaptations and creation of new and tangential jobs. For example, Facebook / Social Networks / Search creating new roles like: Influencers, Social Media Managers, Search Engine Optimization, et cetera.

For the pessimist perspective, I think you could suppose the "end state" of all technological progress in human societies is, eventually, an oligopoly of two industries: bureaucracy (legal) and politics (marketing).

While profit is the main driver, it'll mean smaller teams

Not today, not with current tech, maybe in the near future though

Except in 2020 there were 152 million employed americans, with a productivity 2.4x higher than 1950s, or a cummulative workforce of 365 million 1950 americans working. And somehow they all had stuf to do and work on

I'll be happy if I'm wrong, but are you confident enough to bet that there won't be less need for general developers and engineers and not have a plan in case? Personally I would be looking at my options In case I needed to pivot and not waiting 5o find out.

And if this tech is really revolutionary there won't be new industries? Have we peaked?

> but are you confident enough to bet that there won't be less need for general developers and engineers and not have a plan in case?

I am confident there will not be a lack of work. Whether the roles are similar is a different question. Actuaries and accountants look very different now to before excel was common place. Web developers were not a thing before the internet.

If the revolution comes, and jobs are no longer needed, perhpas there is an industry for prompt engineers. Or model fine tunning experts. Dev ops roles to connect super computers to Modelling APIs. Who knows, but the skills of a decent Engineer are on problem solving, on learning new ideas, on applying problem solving laterally those are such broad skills that is hard for a job market to exist without needing them.

I don't think that's right. Farms may have less manual labor but there's man, many times more people building farming tools, software, tech, etc.

What will happen is you will be able to do more with your time. We are limited by how many people we can actually hire and the output of those people. Now each person can output more and more. So much that we want to build but we don't is because we are limited by output. We need to prioritize certain things for everything has an opportunity cost. Now we will be able to burn down more things more quickly.

Also the math. Imagine developers just became about 30% more efficient. I want MORE of them now as my money is better spent! If my competitor downsizes to remain at their current capacity then I will crush them because I want 30% MORE developers that are coding 30% more efficiently allowing me to release 40% more things for the same money! I crush my competition then and they know this so they have to keep up as it's an arms race.

> Soon coding without an AI will feel as antiquated as delivering food by horse. And resistance is futile because markets will punish those who refuse.

The same way coding without Internet feels antiquated, or coding without autocomplete, or coding without fast compilation times...

If anything, progression of tools has shown several things:

- That the more tools we have, the faster we can work and iterate, the more value we can deliver in less time.

- That IT work doesn't ever end. Tons of IT jobs exist only to support IT itself. The arrival of AWS made sysadmins "obsolete" but on the other hand created the need for SRE and DevOps engineers.

- The existence of tools that let "laypeople" do IT work do not really delete those jobs. Tons of "nocode" tools exist so that people can build their own websites, applications, etc. But designers, coders still exist.

- People still stay behind. Tons of companies still run on a crappy NFS that's hosted in the IT guy closet. Others don't have a webpage and use an @hotmail.com address for email (if they even have email!). The market punishes, yeah, but not that hard.

Try mass culling

Maybe this sounds naive to you, but if I'm not good for anything, what am I supposed to be doing? How should I see myself?

There will be more developing than ever, but humans will sit on a different place in the stack. We'll be more like team managers. Stable Diffusion can make pretty pictures by itself, but only when a human directs it then it can have value.

Most organizations are there to make profit for shareholders, if more profit can be obtained through less hires while still meeting money making goals the you can bet your bottom dollar they will hire less people where possible.

People early in their careers should be ready for this as one day there may be far less times available to them in this field.

Your outlook sounds plausible in a vacuum but doesn’t match reality.

This might be a bigger evolution in the coming iterations and might be the biggest thing since electricity and the internet.

Pretty exciting, but I would also have options or be deep in the thick of it if I were younger.

I might have to revisit it!

I've noticed that the suggestion quality/usefulness varies considerably between projects and programming languages. For a self-contained bash script, it is incredibly useful. For a rails application, less so.

I see copilot as just another productivity tool. Combined with ChatGPT it may save a few roundtrips to Stack Overflow too.

Besides, coding is probably the least of my problems. Dealing with people is harder. AI can help there as well, but ultimately people like to interact with people (see the whole trend about RTO)... we cannot stand each other faces via Zoom => we are not gonna stand talking to an AI.

I'm extremely skeptical about this happening. I haven't seen any evidence that GPT is capable of creating something new or even thinking logically. What's going to happen if you ask it to create something that isn't like anything in its training set?

My experience is that GPT just makes shit up that looks plausible at a glance when it doesn't have an answer instead of just admitting that it doesn't know; this is obviously very dangerous when it's supposed to be writing computer programs. That OpenAI hasn't made any progress towards fixing this makes me wonder if it's even possible for the GPT to understand that sometimes it doesn't understand. At the very least it must be a non-trivial problem.

EDIT: i misinterpreted what you were saying, initially i thought you were asking how i make new things, not how often i make new things. my original reply is below.

weelll, i think about it real hard and do research? Not sure what your point is, but I definitely don't solve these problems by trying to find somebody else's solution to copy, or just dumping a bunch of C code that doesn't do anything and calling it a day like GPT would.

Also, it was recently proven by experts that aliens are living on the earth's core, they breed spherical cows and flying pigs.

But yeah, I somewhat agree with you that a lot of the grunt work are going to be affected, jobs that are by nature purely mechanical, algorithmic or just plain parroting facts. But even then, I still highly doubt language models (today or with the following years) would deprecate those jobs. In the end, it's still a language model that is incapable of thought or reasoning.

If there one's thing I'm optimistic about the recent advances in AI, it's that more jobs will now be creative in nature. Hopefully gone are the days where schools are just mere factories for producing factoid parrots, where intelligence is measured by the size of one's esophagus to regurgitate.

(scnr)

- If you can get more done by working more hours, your job is at risk.

When I was a programmer for most of past life, this was this case. Now I've got multiple decades under my belt and am a h/w and system architect. I can't get more done by grinding. My job depends on sharing information with other people, that have their own schedules, resource dependencies, supply chains, and pricing, and arriving at best fit solutions to move complex projects forward.

I think if you want to protect yourself from being replaced by AI, you need to be part of a larger network where the challenges are more about synthesizing information than grinding.

My $0.02.

Back of the napkin suggests we have approximately the same amount of manual labor in farms today. The difference is that the same amount of labor today is able to feed a much larger population.

This may simply mean much more software written, not fewer developers.

Then came stack overflow and google.

Then came this. I'm not exactly sure what's next, but I do think coding without some type of AI assistant will be extremely antiquated very soon (it already is for me...).

The next generation will look at finding answers via SO, google, and random forums just as we look at people use used books.

Even if it's absurd I still like to buy physical books. The information is better structured and I like holding a book and turning pages.

Why would the machines want to pay us once we can no longer provide them value? Maybe they'll keep a few of us as pets and for sport, but the rest will be sent to the human equivalent of Bovine University.

---- MagicAI, write me a login screen for iPads. The project should be configured to be iPad only. I want a logo in the center and under it the login and password entry textboxes. The password entry should not be in plaintext. Put a login button underneath the password entry.

Actually, the logo + textboxes + login button should be centered as a group. The logo should be centered horizontally within the group as well. Make the login button right-aligned.

The login button should be right aligned within the group, but the text of the button should be centered within the button.

Put "Username" and "Password" labels to the left of the appriopriate text fields

Make sure that the labels are the same width, so that the left edges of the text fields are aligned.

Put a half em margin in-between the labels and text fields. Actually, make the vertical margin between elements in the group a half em, too.

By "margin" previously, I meant "spacing", my mistake. Please fix.

Does the German translation of "username" or "password" cause the text field to be too short, especially on an iPad Mini in portrait mode?

Fix the alignment to work correctly in both portrait and landscape mode. The group should have a 10% left and right margin in both modes.

The keypad enter button should say "Login" when entering text for the password field, but should remain "Done" for the username field.

Great, now add a waiting indicator while waiting for verification from the server.

Actually, put the indicator to the right of the login button, but do not make it part of the group for alignment purposes; it should be in the margin. And turn the indicator off if the server times out. Oh, add some error text for the error.

I said error text, not error dialog. Never give me a disruptive dialog if there is a way to obviously display the error text. Make this a permanent setting on my account. Also, make this a permanent setting on all my colleagues' accounts, and especially the accounts of the low-cost outsourcing companies that make the apps I use.

File bug report to MagicAI HQ that there is no way to make some directions permanent. Include in the report that there should be a way to look at the set of permanent instructions, and automatic reporting if new instructions contradict old instructions.

Disable the login button if there is no text in the username or password field, or if the password is too short.

Whoah, make sure that the text field scrolls so that it is visible above the keyboard, especially on an iPad mini in landscape mode. It should scroll back down to its original position when the keyboard disappears. ----

I guess I'm not seeing how this is too much different from what I actually did in creating the login page in the first place. That's even without the dialogue where you try to figure out why the alignment isn't doing what you told it.

You might also want to keep your instructions in a text file some place, in case you need to change them and regenerate the code. Maybe there should be a preprocessor of sorts, so that you can add comments to the file explaining your reasoning for certain instructions, or to not include some instructions on certain environments. You might also want some way to refer to a set of previous instructions, so you could say "do these things what we did over here". We could call this a "function" since "procedure" sounds too much like ancient Pascal, and math is cool.