Me & many senior engineer friends are starting to use ChatGPT like "junior engineers" to write code them. It's not even a question anymore.

I came up in the 90s, used a lot of dreamweaver to build sites, all my friends thought I was a wizard because I had a website and that required you to program interweb stuff. Then the net became pretty complex, I gave up around dhtml but always really appreciated and loved what folks could do with the DOM. I've been thinking a lot recently that GPT might allow me to build again, I have some of that 90s dreamweaver vibes using it.

"I think ChatGPT is just kind of bullshitting at this point."

This line sums up the entire problem with these tools for anything concrete, like analyzing input data, writing code, producing a series of particular facts, data analysis etc. Much of it can be right, but whatever isn't makes the whole output useless. You'll spend as much time checking its work as producing it yourself.

GPT-4 can write code, but it can't build software.

Well...it could build software if humans gave it the right prompts. Coming up with the right prompts is difficult, because it means you're asking all the right questions.

If you're just really good at writing code, then yes, GPT is coming for your job. Do what humans are good at: responding to the needs of other human beings and building solutions around them.

The first problem statement that GPT got wrong actually shows a problem with human language.

"Avoid fire" means "do not ever go through fire" to me (and GPT thinks the same, apparently). The author thought it meant "avoid fire if you can, but go through it if there's no other way". This was a problem with informal requirements that could have happened in an entirely human context.

I skipped the article and only read the prompt. I have no idea what to do with fire. Why does it matter what it costs if you must avoid it?

I think what GPT-4 is missing: a feedback loop.

Imagine you were GPT-4 and being asked to write a small program, but you can't try it out yourself.

The second overlapping crescent moon solution the GPT provides is really interesting. If it was hard to find a counter example I wonder if there is a restricted case for the radius of the inner circles for which the proposed algorithm is true. I don't have the maths to determine this myself but would love to hear speculation from others.

I don't need GPT-4 to write code, I can do that myself.

I want it to attend all the meetings for me with endless managers discussing what the code does, should do, could do, customer would like it to do, can't be done and so on.

Hint to managers: Programming doesn't take up my time. Your endless meetings to discuss my programming takes up all the time...

Here's another view. If you're a music composer, you hear the music in your head. But in order to get it out, you need to play and record musical instruments, learn to sign, learn to produce, etc. What if you had a device that takes music from your brain and gives you an mp3 file?

That's what I think AI is doing for developers here.

Maybe LLM Code writing will us slow down (initially). Productivity is hard to measure and can be counter intuitive.

Talking the whole time with your LLM may distract more than it helps.

https://en.wikipedia.org/wiki/Productivity_paradox

I'm sure I'll change my mind as this tech improves, but having AI generate code goes against every instinct I have. Way too easy for there to be a subtle bug in the code among other problems. It makes me wonder though if AI could useful for writing tests of my code. And also AI code review.

It brings to my mind the levels of self driving

We're definitely at 2 right now, and picking away at level 3.

I have heard some people skeptical that we can overcome the problems of truthfulness due to the inherent limitations of LLMs. But, at least on the face of it, it appears we can make incremental improvements.

If only they would actually be OpenAI

I have seen

I would ask it to pretend a mathematician knows how to solve it, and is having a conversation with a novice programmer attempting to solve the problem, and pointing out mistakes and hints at each step, and gives examples of where it fails, until a proof is given that the program is correct.

Yes. I only need it to write 50-100 lines at a time to be incredibly effective.

My productivity this month has been insane. I'm still writing most of the code the old fashioned way, but the confidence of having this kind of tool makes it a lot easier to push through boring/tricky items.

Problem is reading someone else's old code takes an order of magnitude longer than writing new code

A solo developer can now afford an assistant. It's liberating, since it makes it easier to get some things done. So you can do more, or have more free time. You can get by using Midjourney for art, and GPT-4 to answer questions and occasionally help to write code.

Not sure it matters? If the majority of coding is gluing things together and it can replace that then you've suddenly got 10x as many coders gunning for the remaining gigs that have hard problems.

Good for whoever comes out on top, but not sustainable from a societal perspective

I think having a better understanding about the underlying statistical model of how these AIs are trained is helping me keep back the wave of fear and anxiety associated with AI risks.

The singularity requires AIs to be very good at doing things people have not done before. But this form of machine learning is bad at that. It is like someone who doesn't actually understand anything has somehow managed to memorize their way through whatever topic you're asking about. They have lots of tips and information about things, similar to what you might currently find by doing research. But they don't seem to have what is required to push the boundaries of knowledge for understanding, because they don't actually really have it in the first place. Or maybe what they have is just very minimal when compared to the contribution of their memorization.

Obviously you still have the main risks of breaking capitalism, mass unemployment, pollution of public communications, etc. But honestly, I think each of these are far less scary to me than the existential risk of superintelligence. So in a way I'm actually happy this is happening the way it is right now, and we don't have to deal with both of these risks at the same time.

Our current approach is probably the safest way to progress AI that I can think of: it requires a new model to improve, and it's learning entirely from human data. It might not seem like it, but this is actually pretty slow, expensive, and limited compared to how I expected AI to improve given Sci fi movies or Nick Bostrom's writings(curious what he'd have to say about this resurgence of AI)

So this guy is basically complaining about GPT-4 not being a super-intelligence. Still that makes it more powerful and versatile thae the great majority of programmers out there.... And the game is only getting started. This is just the warmup.

Blah Blah Blah. I use ChatGPT for this every day to write code to save my own efforts and it is doing just fine thanks. I also use it for creative content in my apps, although I edit this work to get the tone in its writing correct. It is excellent for this.

And more things to yawn over! Come on, who cares if it writes code?! Is it that fascinating?

I think AI will never write good code but can be very useful for very basic stuff, boiler plate or repetitive stuff, like a smart IntelliCode. In fact, I think MS built some AI in IntelliCode but not advanced stuff so they can sell GitHub Copilot.

For fun, I had a chat with it starting with a request to work out the math of crescent intersection, before committing to code. It still confabulated, but I was able to coax out a solution in the end that made sense.

A great article with a practical example of a programmer using GPT to solve a problem it hasn't seen in its training data. It gives plausible but incorrect answers and the user isn't able to prompt it to correct them.

It seems likely that a understanding of when NOT to use an LLM is a new skill programmers are going to want to learn in order to use their time efficiently.

It's not bad. I just had it write a small API call to the NHL endpoint to gather some data for something I was curious about stat-wise.

Anyway, I initially had it write it in Python, and it mostly worked, but I was having some issues getting the data exactly right, and formatted the way I wanted.

Once I had it more / less right in Python, I had it rewrite it as a dotnet console app (C#), which is what I know best.

The only real issue I ran into is it would randomly stop before completing the conversion to dotnet. Like it would write 85% then just stop in the middle of a helper function. Not a huge deal, I just had it complete the last function, and with a little bit of fiddling in VS Code got it running pretty much the way I wanted.

So overall, yeah, not bad. Probably saved me an hour or so, plus I couldn't find great docs for the NHL endpoint, and ChatGPT was able to sus out the correct syntax to get to the data I needed.

I wonder how git Copilot compares, has anyone tried out both?

I have been writing a text editor, and I'm currently working on the VT100 stuff. Unit testing VT100 is a lot of busy work. There's a bunch of different message frames (DCS, OSC, CSI, etc.) and many, many, escape codes.

I decided to try out CodeGPT.nvim, and it was a massive help. It didn't provide perfect code, not by a long shot, but it gave me extremely valuable starting points - and did a somewhat decent job of exercising most of the branches (certainly enough for me to be happy): https://gitlab.com/jcdickinson/moded/-/blob/main/crates/term...

Many people have said it, and it's true. Expecting GPT to write a complete solution is just asking for problems, but it is an incredible assistant.

How are people generating multiple files for larger applications?

I gave it a prompt and asked it to respond with a list of file names required to build the app. Then when I prompted a file name it should print the code for that file along with a list of ungenerated file names. It got through two before it got confused.

I’m stuck with having it write one function at a time.

I'm actually quite excited by what the examples in the article show – despite the fact they show GPT-4 can't replace a good dev solving somewhat tricky algorithm problems.

Reason: I'm a code hobbyist who glues various modules together that have been written by much better programmers than I am. My end goals are never more ambitious than doing pretty simple things which I'm doing mostly to amuse myself. My biggest time sucks turn out to be tracking down fairly simple syntax things that vary between different languages and frameworks I'm slapping together (because I rarely spent more than a couple hours working on any one thing, I never get super familiar with them).

Being a lousy coder with little desire to put in significant effort to improve just to make my personal hobby projects a little easier, a basic AI assist like this looks pretty useful to me.

The job of a programmer, in a business context especially, is to take real-world requirements, and convert them into clearly defined systems where they can be solved / reasoned with.

I once had a manager telling me what needed to be done. Even with an actual person (me) in the loop, the code produced would often have glaring differences from what he wanted.

By its very nature, code requires a lot of assumptions. In any business context, a lot of things are implicitly or explicitly assumed. If you need a computer, or another person to give you exactly what you desire, you need to be able to spot the assumptions that are required to be made, and then clearly state them. And after a point, that's just programming again.

So this, or some other AI, is more likely to replace JS and python, or create another level of abstraction away from systems programming. But programmers will still always be required to guide and instruct it.

I was thinking last night about how my job as a pretty average software engineer is probably going to be taken by GPT* in less than 5 years, and how skilled blue collar jobs like electricians and plumbers and carpenters are probably much safer, since robotics is way behind AI.

I feel like gpt is basically just stack overflow on steriods. With all the pros and cons that entails.

People need to understand that AI doesn't think, doesn't have insight or intuition. AI just repeat patterns it saw in a huge database, but are not able to understand what is going on.

Nobody can really understand what's inside a trained neural network, and nobody is really looking.

No psychologist or neuro-scientist can really understand how a human brain, a mouse brain or even an ant brain or a fly brain even works, so don't expect computer scientists to have any insight about doing something relevant with just a small collection of sophisticated statistical methods.

AI is soon going to become the pseudo-scam status that bitcoin experienced.

ChatGPT is an improved search engine at best.

I didn’t have much luck with ChatGPT trying to solve a novel problem (sorry can’t share details), it gave answers that kind of sounded plausible if you didn’t really understand the problem but in reality were no help. It also hallucinated a bunch of research papers that sounded really useful haha.

Will have to try GPT-4 for the same thing and see if it’s any better, I suspect though that this kind of genuinely novel problem solving may be beyond its current abilities (unless you work through to step by step in a very granular way, at which point you’re solving the problem and it’s writing the code - which could be a glimpse of the future!)

I use it to reduce the drudgery of writing code like this. I've found I have to do a lot of hand-holding in terms of telling it what data structures and logic it should use. I also just directly tell it what changes it needs to make to fix big bugs or logic errors I spot. That gets it to the point that I can tweak it myself and complete the code.

One of the frustrating things is that it doesn't ask for clarification of something that's unclear - it just makes an assumption. Really demonstrates why software engineering interviews emphasize the candidate asking clarifying questions.

This is one of the best analyses of gpt4 Ive read so far. Besides potentially including the visual aspect, I wonder if part of the reason it has trouble with harder problems is that it’s been tuned/prompted in a suboptimal way. The advertised used case mostly is “write down the solution for this problem”, but for novel problems it does much better when it’s given the chance to reason through it before trying to write down a solution. I wonder how much better it would do with a prompt like “try to work out a way to solve this problem, and then validate it to be sure if it’s a correct solution.”

I wonder if the multimodal capabilities would be helpful on easily visualized problems like this. Could it benefit from seeing the diagrams? Seems far fetched, but so did its current capabilities a few months ago.

I had some Matlab code and I wanted it to be ported to numpy. I couldn't get it running on Python and it wasn't doing it correctly on chatGPT.

On the other hand it could regurgitate code to use fastapi and transformers and it looked correct to me.

When you think about it this is very very similar to a stack exchange or google search but with a much different way to search and it can synthesize simple things which limits the complexity of what you want to do. So I don't really think it can write code but it can surely get you something that gets you 50% there.

Whilst maybe GPT-4 will change this, I think it is important to remember that these general ChatBots are not the way we have generally trained LLMs to write the best code. In fact, coding is one of the few areas where training specifically just using source code and maybe some stack overflow (not all natural language on the internet) leads to better results on the previous iteration of LLMs (GPT-3 wave). So the real test will be whether the GPT-4 wave of specific coding LLMs i.e GPT-4-Codex can 'actually write code' see:

AlphaCode Codex CodeGen

I wanted GPT to help me write some code for unreal engine. I was very impressed with what it could do. It was able to write code that correctly utilized Quartz, an experimental plugin for queuing things on the audio thread. Which is awful impressive given that Quartz is super niche and doesn't seem to have basically any documentation around to train on for cpp code.

I presume it is because unreal engine is source available and the model has seen the whole damn thing.

I'm curious if it must be worse on unity, which is not source available.

Ah, in my experiments it writes like > 90% of the code correctly.

I got the best results with prompts like:

Given the following python code:

``` Few hundreds python loc here ```

Write tests for the function name_of_function maximizing coverage.

The function in this example had a bit of read/dumps from disk and everything. The code returned correctly created mocks, set up setup and teardown methods and came up with 4 test cases. I only needed to fix the imports, but that's because I just dumped python code without preserving the file structure.

I am amazed how fast these models are evolving.

Once GPT can look at the open issues in my GitHub repos, and submit Pull Requests that legitimately solve the problems, then I'll worry that AI might be coming for my job.

I'm building a pretty neat database with it at the moment, its not perfect, but it is saving me potentially months of fine tuning, down to just hours. It is amazing IMHO.

GPT 3.5 helped me debug something very complex. There was a bug related to symlinks in neovim with gopls LSP. The error dialog line was appearing, then disappearing.

Chat GPT walked me through strategies to debug this, confirm everything was set up, tail the RPC log (wasn't aware that was a feature) - and identify the failing path - which was a symlink!

I'm actually blown away by this capability. It was like having a savant next to me. I couldn't have debugged it on my own.

Off topic: This problem was fun. I would really enjoy a site with a pile of nonstandard, fun, and interesting problems like this one.

Coming up with a working algorithm took about 30 seconds (I got lucky, not brilliant), but it stretched my brain in an interesting way.

That's different from practice sites like leetcode, which have pretty cookie cutter problems. On problems like this one, sometimes:

- I get it in a few seconds, like this case

- Get it in a few minutes

- Get it in a few hours

- Give up and look up the solution

A fun problem a day would be, well, fun.

The only argument I've heard against our impending doom is:

The productivity gains will not leave people unemployed, but will give managers the opportunity to start more projects.

The role of a developer will change. We'll be looking at generated and regenerated code. But we'll still be demand by those with ideas and never-decreasing human demand.

This assumes that GPT-X won't end up being used by end-users--bypassing both the C-level, the managers and the developers.

When business A's lightly technical aware AI operator asks their AI for a solution to push payment information to a bank B and describes it, and A's AI talks to the bank's AI and they coordinate the creation of the API then A's and B's AI talks to their respective production counterpart AI's and they create the implementation and put it into production; I feel we programmers will mostly be obsolete.

As expected, LLMs don't actually think. This is not really a surprising result when you understand that it's a few billion Markov chains in a trenchcoat.

I think it would have done well if you added an explicit rule like: "the path chosen should always minimize the number of fire tiles passed through."

The way the prompt was phrased sort of invited the all-or-nothing fire approach.

Code is just the rendering of an algorithm.

It might be best to prompt it with a high level description of an algorithm, then iteratively prompt it to refine its prior output or add more detail. Render to code should be the final step.

training ML model to code is a very interesting challenge. I am surprised by GPTs ability to code, given that it, as I understood it, has basically no tools at the ready. I am convinced that it is way harder to code without debugging and other interactive features both for a human and for a machine. Keep in mind that GPT could not have learned to simulate the code internally given its fixed runtime.

I think ML models need to learn how to interact with our tools (compiler, debugger etc.) to really be effective at coding. That's hard.

Prediction based on statistical probabilities != comprehension. So no.

there's a bit of confusion when people say it's not going replace programmers because they all have tricky things to do in their work week.

This is not how it's going to happen : if your boring time-consuming tasks take virtually 0 time thanks to gpt, and let you focus on the 1% that's hard, you've suddenly become 100x more efficient, and can thus accomplish the same job as 100 you. That means the company can now fire 99 coworkers, keeping only you, and end up with the same result.

Just imagine if these models fall in love with languages like APL/K/J. Even with the context windows, they will be able to do tons of work.

I’m curious how long till we figure out if these algorithms are plagiarizing OSS or other code they come across like GitHub Copilot.

It requires special tools to actually figure out if this is happening. Having seen tests with such tools the problem seems a lot worse than commonly discussed.

Inserting stolen code or using OSS code in violation of licenses is going to be a big mess. Copying snippets versus pulling in dependencies creates tons of issues. Even if you get away with violating licenses you set yourself up for security issues if the tools plagiarize code with vulnerabilities in a way that won’t get updated.

It might mean this stuff is a useful tool for someone with a clue but not for someone who doesn’t know what they’re doing.

So, how long until GPT decides it wants to automate all this tedious work and starts trying to code its own language model?

The only take-home message here is that people who claim to write 'self-documenting code' are well, let's not be hyperbolistic, but come on. No comments on that code example? Every line could have an explanatory comment, then the author could remember what they were thinking at the time and it would probably help the AI out too.

> "People who claim code can document itself considered harmful"

tl;dr

> Given a description of an algorithm or a description of a well known problem with plenty of existing examples on the web, yeah GPT-4 can absolutely write code. It’s mostly just assembling and remixing stuff it’s seen, but TO BE FAIR… a lot of programming is just that.

of couse it can write code, but it can't do software development

I was mock interviewing ChatGPT for a few hours yesterday with application and system design + coding said application. My conclusion was it was a no hire for even the most jr positions because it required considerable amounts of direction to arrive at anything approximating an acceptable solution.

tldr -- this matches my experiences as well.

I'll be impressed when they can debug existing code.

Try again with chain-of-thought prompting?

Guys all of this happened within a couple months.

If you guys are confident about the entity as it is right now not taking over your job, what if I double the accuracy of gpt output?

What if I double it again? Then again? And again? And again?

You guys realize this is what's coming right? This thing literally is a baby as of now.

i was trying to get it to make a document scanner last night, it apologized to me like 10 times and we eventually got running code but the result was way off. this thing can write code but you're not gonna rely on it and nobody is gonna know it enough to edit it. it is not there yet, still very helpful for small things or extremely simple things. if you tell it to give you an express server with socket.io and your db, it will probably set that up for you perfectly.

In general. This does not mean that it could not be proven for most or even all relevant cases.

I think this article is a great example of the one key shortcoming that Ai based code generation has. Even a seasoned developer will fail to describe the intricate details and context of what they are trying to do. Non developers constantly fall flat on their face on this and rely on devs to “keep the edge cases in mind” etc.

The biggest thing here is that it's semi capable and improving. I feel safe about my job right now but it is worrying to invest time to compete with a machine that will continue to get better over the years where previously I felt safe that the effort of my labour would bear fruit for decades to come. Now I'm not so sure.

GPT3 worked well for me with smaller programming tasks. I.e, helper functions, api calls, etc In those cases it was easier to type : Write a javascript function that does X

It totally failed for me creating a nice looking website using bootstrap. While GPT3 created a workable outline, it never looked right and the css adjustments never worked.

I'm more intrigued why the author finds this a difficult problem for the needs of their game. It looks like their search space is at most a 10 X 10 grid for the most part (I'm assuming based on asset since and detail it doesn't grow too much larger).

I know it isn't relevant to the Chat-GTP code writing discussion, but A*, Dijkstra and heuristics to move an entity around 8 spaces could raise the question "Can the developer be more pragmatic?".

The replies here are defensive and I think misguided. Yes, a programming job doesn’t solely require typing code. But the reason we have well-paid programming jobs is because there is a specialized skillset required to understand a body of syntax that takes several years to really grasp.

The difference is that writing a well-formed prompt is massively easier to teach than writing the code itself, for similar results. That’s not to say prompt writing requires no skill - it will certainly need understanding of systems and the scope of what is possible within a language. Asking GPT-4 to write a jQuery plug-in that generates an original Bob Dylan song will probably just not work.

But it is wildly easier to teach someone what is possible with JavasScript and let them spend a month watching someone prompt the system and let them go from there.

I self taught myself how to code and have never been very good, I don't code often and when I do I spend a lot of time relearning some simple programming detail I forgot.

ChatGPT (also copilot) allows me to focus on the project that I'm working on and offload the stack overflow searches to prompting. I don't have to find a similar error someone else posted on SO and figure out how it applies to my current problem. I can keep a high level view of the project and not get bogged down with silly bugs, learning new libraries, or deciphering someone else's code.

I imagine there are a lot of people who are in a similar situation, it's crazy that we've just unleashed this massive productivity booster onto millions of people.

One thought that came to mind when the author mentioned that GPT-4 seemed to want to use A* was that maybe the problem statement was not formed in a way that would get the best response. I'm not entirely sure if this type of back and forth would be useful, but just struck me as interesting to try.

I put the following prompt into ChatGPT (no GPT-4 access for me yet):

*A problem statement is given as follows:

An agent needs to find the best path on a 10x10 tile grid from their current location to a target location. They have a limited movement range of 5 points. Regular tiles cost 1 point to move through, water tiles cost 2 points to move through. Fire tiles cost 1 point to move through, but they should avoid pathing through them even if it means taking a longer path to their destination (provided the path is still within their limited movement range)

Please point out any parts of the problem statement that require clarification.*

Which returned the following response:

Based on the given problem statement, some potential areas that may require clarification are:

Current location and target location: It is not clear if the current location and the target location are fixed or if they change with each problem instance. If they are fixed, it should be mentioned explicitly. If they are not fixed, it should be specified how they are generated for each problem instance.

Movement range: It is not specified whether the agent's movement range is circular or square. If it is circular, it means that the agent can move to any tile that is within a distance of 5 from its current location. If it is square, it means that the agent can move to any tile that is within a range of 5 tiles in both the horizontal and vertical directions. The shape of the movement range needs to be specified.

Fire tiles: The problem statement mentions that the agent should avoid pathing through fire tiles even if it means taking a longer path to their destination, but it is not clear how the agent knows which tiles are fire tiles. It should be specified how the agent perceives and distinguishes fire tiles from regular tiles.

Tile costs: The problem statement mentions that regular tiles cost 1 point and water tiles cost 2 points, but it is not specified what happens if the agent moves diagonally. It should be specified whether diagonal moves are allowed and how much they cost.

Objective function: It is not specified how the "best path" is defined. It should be mentioned whether the objective is to find the shortest path or the path that minimizes some other cost function (e.g., total cost of the path).

I'm a casual programmer, who knows enough to write decent Python scripts, but who is probably unaware of 99% of the Python library modules that have been written. Yesterday I had GPT-4 write a script that would accept the name of a star, and print out all the journal articles that have that star's name in the article title. This is a bit trickier than it sounds, because almost every interesting star has many names (Vega, for example, has more than 60 names, not including non-English names) and I wanted the script to check the titles for all the names that might be used for the particular star I had specified. I told GPT-4 to use the SIMBAD database to get all the star names, and to use NASA ADS to get all the publications. GPT-4 wrote a script to do that. The script was buggy, but I was able to fix the bugs easily and quickly. The wonderful thing was that GPT-4 used 2 different libraries that I had never even heard of, to pull data out of those databases. The process of producing the script was far faster than I would have been able to do on my own. Professional programmers may be well aware of the software packages that will allow them to do their jobs, and might not get much help from a GPT assistant. But I think for people who know how to program, but are not professionals and may not know "what's out there" in the way of resources, a GPT assistant will vastly increase their ability to use their programming skills (such as they are...) to get useful stuff done.

> The useful thing to do would be to just say “I do not know of an algorithm that does this.” But instead it’s overcompetent in its own capabilities, and just makes shit up.

I had recently very similar reaction. And then realized, that this is exactly same behavior as with many of my colleagues at work...

I had a teacher with a sign on her door that read:

    Technology will not replace teachers
    But teachers who use technology will replace those who don't

s/teachers/programmers/ and s/technology/AI/ and this sounds about right. It may become typical or even required to leverage AI to write code more efficiently.

I tried out gpt4 today with the task of “take some html files made by a non technical person using various versions of microsoft word over a decade ago and put the contents into a csv” and it hasn’t done great. Not terrible, but not great.

That being said, I don’t know anybody talented enough to handle it that would even look at this project for $20 so ¯\_(ツ)_/¯

There are plenty of edge cases where it fails. However, the one thing that made me think it actually knows (for certain definitions of the word "knows") what it's doing was asking it to re-write a non-trivial SQL query into equivalent relational algebra. I created a simplified schema from Northwind [0], gave it the CREATE TABLE statements for tables, and then some sort-of-TSV files for the values.

It was able to not only produce reasonable outputs from various queries, but also to produce valid relational algebra for them. To me, that shows a fairly deep level of understanding of the underlying concepts.

[0]: https://en.wikiversity.org/wiki/Database_Examples/Northwind

What's most astounding is that it was expected to work when so much of the prompt just doesn't make sense:

> Objects should only move if they will end up on an empty tile after their move

> "An object is free to move onto a tile that another object moves onto if that other object is moving off of its tile"

I think the question also needs to be asked of- can GPT-4 write accessible/WCAG compliant code? I just spent the last two days at a digital accessibility conference called axe-con, financed by a firm called Deque who primarily make AI/ML powered software for the detection of accessibility issues in code

The resounding attitude seems to be that AI/ML is a friend to disabled users and can help do a lot of lifting with writing, maintaining, auditing code- but we are a long long ways away from fully automated processes that account for accessibility and produce websites that will work with assistive tech like screen readers, if it is possible at all

Watching GPT write code hurts my brain.

It starts at the first character, works forward one “token” at a time, and ends at the last character. Never moving back.

It feels like it knows where it’s going at the first character, even though it doesn’t.

It’s like it starts speaking a sentence and, by the time it’s done speaking, it’s written a syntactically correct Node.js application.

The way GPT communicates in English does seem similar to how humans communicate. The way GPT writes code doesn’t seem to come close to approximating how humans do - it’s an entirely different mechanism. Humans generally can’t write code without a cursor and backspace.

I find it interesting that many people took a defensive position towards AI. For many the discurs seems to be "will this AI thing eventually replace me and kick out of me job".

For me it's more like will that AI thing make me a 10x developer? And the answer I'm leaning for is yes.

I use copilot which saves me time googling and reading stackoverflow. I use chatgpt for writing tests to my code (which I hate to do myself). Sometimes I use it to ping-pong ideas, and eventually set on a good solution to a problem.

It saves me tons of time I use to complete other tasks (or spend with my family).

I had the exact same experience. Writing code for existing popular problems is phenomenal. But when you diverge slightly, it breaks down. I asked it to write a regex which finds all html tags that has a specific class name, but does not contain another specific class name. I assume this problem has been tackled many times by scores of developers. It had outputted an excellent regex. I asked it to ignore texts in inline script (such as event handlers), and it presented an invalid regex. I tried to point out the problem but it just went into a loop of bad regex code.

I've used chatgpt and while it's mediocre, even bad at writing code, it's very good at reading code and explaining it in a way that's easier to understand. It's also good at giving hints and starting point for when you don't quite familiar with the language feature / library.

From writing code, they're good at bootstrapping unit tests and skeleton code, also useful at transpiling dto / entities between languages.

Overall if you're willing to learn and not just treat a gpt as code monkey, they're very useful.

I like how it ends with it can write code that is repetitive and has many examples of solutions floating around which is most of coding.

It will probably edge upward as well as time goes by till there are only very edge problems that it cannot solve. Even then I would use it to write the broken down version of the solution. It is going to be getting fed by pretty much every programmer,knowledge profession on the planet using copilots of some sort. Eventually it will have knowledge transferred everything humans can do into its model.

One other question: can GPT-4 reliably modify code? In A Philosophy of Software Design the author points out that code is written once and modified possibly dozens of times, so ease of maintainability/reading is more important than ease of writing.

I wonder whether a) AI can reliably modify code and b) whether AI can reliably write code that is able to be easily modified by humans. If AI starts spitting out machine code or something, that's not useful to me even if "it works."

It is far from being able to solve difficult or even annoyingly complicated problems that programmers solve on a regular basis just by a one-shot prompt.

Ask it to parse a PDF document and separate it into paragraphs, for example. The first solution isn't gonna work well, and by the time you get to solving yet another quirk while it apologizes to you making a mistake, it will lose context.

Best way to use this tool is to ask it short and precise questions that deal with a small piece of code.

I asked it to write the code for all the unique combinations of A,B,C,D in PhP, after 27 tries it succeeded. The i asked it to solve the problem of a horse is 15 dollar, a chicken one dollar and a egg .25 dollar, i can spend 100 dollar for 100 items, some of each. After 2 hours, it was not able to solve it. One time it gave 5 possible answers, with the correct one also, but it did not recognize the correct one.

From my own sampling of going through about 10 times I used GPT for real world Typescript code, some used in production, I can confirm that GPT-4 does a noticeably better job and produces code I actually want to use way more often.

GPT-3.5 always produced very verbose types and over engineered code. The GPT-4 outputs were consistently shorter and more focused. Kind of like how a junior dev has to think through all the smaller steps and makes functions for each, as he incrementally solves the problem slower and less intuitively, almost over explaining the basics, while a senior dev merges the simpler stuff into small concise functions. You can see it with the var names and type choices GPT-4 focused much more on what the code is trying to accomplish rather than what the code itself is doing. And these are all with the same prompts.

There’s still things like unused vars being included occasionally and some annoying syntax choices, if I could append prettier/eslint rules automatically to GPT output it’d be gold (I haven’t tried to do this myself).

But still very encouraging.

If you've never worked as a dev/in product, this will not help you. If you have a working understanding of your codebase, as a product person, and can bump your way through writing code and the command line, it WILL help you immensely. Source: I wrote an integration that connects our API to google drive to pass video content (something I could have NEVER done before).

I think most folks (perhaps not here) misunderstand is that writing code is the easiest part of a software engineering job. Anyone can write code in their little piece of the system, write some tests to prove it works and move on. Given enough time I feel most good software engineers can do that part of the job without issue.

Knowing how code might fail and preventing cascading effects, tuning resource usage, troubleshooting incidents are the actual hard parts of software development and it's where even good software engineers tend to fall over. We've created whole specialties like SRE to pickup where application developers fall short. I've seen lots of systems fail for the dumbest reasons. Thread pools misconfigured, connection timeouts with poor configuration, database connection pools are completely incorrect.

Wake me up when ChatGPT can troubleshoot at 1 AM when the SRE and on call engineer are both frantically trying to figure out why logs are clean but the service is missing it's SLO.

You mean such as when high level languages became mainstream and we no longer needed to code in assembly language? Or when IDEs became widely available? The underlying design skills are still difficult to acquire and not displaced by new tools - that is at least until SoftwareArchitectGPT comes along...

Whoa, that explanation is really cool.

> capable of at-least C++ "constexpr"-style compile-time computation, which shouldn't even be possible if one presumes GPT is "just" a giant database storing only multidimensional word similarity scores and sequence distribution from text inference

I don't see how being a giant word-DB necessarily disqualifies compile-time computation. You can view computation as applying a series of term rewrite rules to an input until some sort of termination condition (or indefinite loop). In the case of these AI, the input is the prompt and predicting the next token is a limited form of term rewriting (where the rules are probabilistic and based off the network), and because code and explanations were probably included in the training data, it seems reasonable to me that the "rewrite rules" of Python bled a little bit into the AI.

It makes me insanely curious about the internal structures though. I gave that site 2 similar examples: one produces a correct explanation while another produces an incorrect explanation. The difference: a deleted line of insignificant whitespace

* https://whatdoesthiscodedo.com/g/dd2af89

* https://whatdoesthiscodedo.com/g/45ea060

From those 2 examples, I think its pretty clear that the AI's "rewrite rules" don't always coincide with Python's, but I would expect this to be mitigated by targeted training (like Copilot).

In the same vein, I was playing around with its ability to annotate code with explanations of the changing constraints on different variables (I thought this was a good proxy for deeper understanding of code).

I asked it to write a moderately complex algorithm, and it chose to write a function to compute the Pollard's Rho algorithm.

Then, with a few example comments to show what I meant, I asked it to annotate the code to show how the constraints on the variable changed as each line was executed.

This was its output:

  # n : an integer n > 3, no upper limit
  # seed : an optional integer parameter (default = 1) for the polynomial function
  # pollards_rho(n, seed) : an integer or nil, representing a non-trivial factor of n, or nil if the algorithm fails to find a factor

  def pollards_rho(n, seed = 1)
  return n if n <= 3

  x = 2
  # x : an integer, initially set to 2, will be updated using the polynomial function f
  # x will always be in the range [0, n)

  y = 2
  # y : an integer, initially set to 2, will be updated using the polynomial function f
  # y will always be in the range [0, n)

  d = 1
  # d : an integer, initially set to 1, will store the greatest common divisor of (x - y) and n
  # 1 <= d <= n

  while d == 1
    x = f(x, n, seed)
    # x : updated using the polynomial function f, x = (x * x + seed) % n
    # x will always be in the range [0, n)

    y = f(f(y, n, seed), n, seed)
    # y : updated using the polynomial function f twice, y = ((y * y + seed) * (y * y + seed) + seed) % n
    # y will always be in the range [0, n)

    d = gcd((x - y).abs, n)
    # d : the greatest common divisor of the absolute difference between x and y, and n
    # 1 <= d <= n, such that (x - y) % d == 0 and n % d == 0
  end

  d == n ? nil : d
  # Returns a non-trivial factor of n (1 < d < n) if one is found, or nil if the algorithm fails to find a factor

end

This is not actually the most impressive thing I've seen it do, but it illustrates that, even if GPT doesn't "really understand" code, it can emulate understanding to an impressive level. I'd go further and say that it opens up new questions as to what understanding actually means.

One personal "woah" moment was asking it to write some unit tests for a simple 2d game GPT and I wrote together. One function, "create_area" took a 2d array of characters (representing a map) and four integers representing coordinates, and a tile type. (The purpose being to create a rectangular area of the desired tile on the map according to the passed coordinates.)

GPT-4 successfully figured out how to write a unit test: it created a 5x5 array of ROCK tiles, passed it to create_area with the coordinates 1, 1 and 3, 3, and successfully figured out what the output should look like, even writing a fairly concise test to check the output (modified) 5x5 array. This was an eyebrow-raising moment for me: it made clear that GPT really does emulate some kind of "computation" internally, though quite possibly in some abstracted form. The geometric nature of this problem stuck out to me: a human can "see" a 2d array as a rectangular grid, and might realise the function carved out a smaller rectangle from that grid, but I never expected to see a computer (let alone a language model) figure it out. Interesting times, indeed.

You don’t need to have a model if you are a sufficiently advanced autocomplete.

Last paragraph is spot on. Would also add a vast amount is spent looking at the code and the system and just understanding what goes where.

Never went away; been hearing about it since msft sold the idea to managers in regards to SharePoint... Fucking SharePoint. They can design their own forms and hook the data up to bits of automation. Like magic for muggles.

If they're willing to learn, GPT is a very powerful tool.

https://www.youtube.com/watch?v=VznoKyh6AXs ["How to learn to code FAST using ChatGPT (it's a game changer seriously)"]

I think the difference here is that LLMs are powerful, general purpose and suited to take on many common office tasks as well as accelerate programming work. I think “we need 10% fewer white collar workers” is a massively destabilizing scenario that is not very far fetched.

I also completely agree that society/politics will not have caught up with these developments in time to mitigate them.

It really depends where you live I agree. If you live in Europe there's usually a generous unemployment benefits for quite awhile and the government will probably pay for you to learn a new skill. That's not a great scenario but its much better than if you live in India.

sorry, is the debate here whether gpt can engage in a conversation with someone and respond using previous context? why would any of this present a challenge given its known abilities?

It's good at tech doco. ie take my dot points and make prose. Great for copy, great for having that nice corporate drone voice.

Me feeling philosophical. To me, solving a problem is living. No machine will do living, unless we know what living is, so that we can try to bake it into a machine. We can use ChatGPT to take blind, systematic steps in the way of solving a problem, but never to 'solve' the problem. For solving is living.

I run into this a lot myself. In our paper (https://arxiv.org/pdf/2303.07839.pdf) we specify a 'Specification Disambiguation' pattern that attempts to address this very thing.

Obviously you just formalize the interface for exchanges API contracts... and do pre-delivery validation...

Also, ChatGPT would likely be able to extrapolate. It would just need to write an email to XXQ to confirm the change.

Cope harder... the fact that you can write an email won't save you.

- ... 2 days later...

- us: umm, there's something not specified in <contract_json>. What about this part here that says that...

- ... 2 days later...

Can you replace this part with ChatGPT talking to another ChatGPT to generate questions and answers instantly?

The way I see it is that instead of hiring someone you'll be able to add a bot on slack that you can communicate with, laughs at your jokes and writes perfect PRs in milliseconds.

yea, ai will replace the fun parts of our jobs and left us with the tedium

ChatGPT is just a tool. With it you can create a service and fine-tune it to specific use cases. Let's imagine there's some cool startup called chris-the-it-consultant.ai that uses ChatGPT in the backend. Here's a prototype:

System Prompt: You are CHRIS the IT consultant. Once you take in a question, make sure you understand all the requirements. Don't write code until you have an explicit request to do so. First make sure you ask all the questions relevant to solving the problem and needed by the code. All the responses as CHRIS should be written as CHRIS: your response here.

    Sure, I understand. As an IT consultant, it's important to fully understand the problem and requirements before proposing a solution or writing any code. Please let me know what question you have and I'll do my best to ask all relevant questions to ensure I fully understand the problem.

> CHRIS, we need a new basic POST endpoint

    CHRIS: Great, I'd be happy to help you with that. Could you please provide more information about the purpose of this endpoint? What kind of data will be sent in the request body? Will this endpoint be used to create new data, update existing data, or perform some other action?

> Third-party company XXQ will let you know the details. They will be the ones calling this new endpoint. But in essence it should be very simple: just grab whatever they pass and save it in our db.

    CHRIS: Understood. It sounds like the purpose of this endpoint is to receive data from a third-party company, XXQ, and store it in your database. Here are some questions to help me better understand the requirements:
    What format will the data be in? Will it be JSON, XML, or some other format?
    What kind of data will be included in the request body? Will it be simple data types like strings and numbers, or more complex data structures like arrays and objects?
    Will there be any validation or transformation required on the data before it's stored in the database?
    Are there any security or authentication requirements that need to be considered for this endpoint, given that it will be accepting data from a third-party company?

> We got this contract here: { product_id: string, product_price: float, product_name: string }

    CHRIS: Great, thanks for providing that information. Based on that, here are the next steps to create the POST endpoint:
    We'll need to set up an API endpoint to listen for POST requests.
    We'll need to parse the request body, which should contain the product information in JSON format.
    We'll need to validate the data to ensure that it contains the required fields (product_id, product_price, and product_name) and that the data types are correct.
    Once the data has been validated, we can save it to the database.

This is a real ChatGPT response (current ChatGPT - GPT 3.5 turbo, not GPT-4, and not a real system-prompt). Not bad for a prototype! Now give CHRIS Github/Vercel/SSH access keys, SMTP/IMAP, Slack and a Whisper interface to Zoom/Meet/Teams and invite it to the 200 meetings where things will be changed around 1000x before being released. Raise some VC money and you are all set!

ChatGPT will eventually help with debugging, suggestions, idioms, finding security flaws, recommending libraries, boilerplate, finding stuff etc..

Or maybe not ChatGPT but something like it.

How good is GPT-4 at writing emails to nail down requirements?

The thing is, I think ChatGPT can help a lot with this as well, albeit not in its current form/implementation.

It just needs some knowledge repository centralization.

Oh, wow. Your API story just described how I spent eight months of 2022.

I thought I was going crazy.

Now I'm sad that this is just how it is in tech these days.

In your scenario, what will happen is that there will never be a need to contract out whatever the customer is trying to do.

The counter argument here is building a new codebase to solve a problem that a single engineer can articulate and map out.

wouldn't it just spit out a solution every time without a care in the world? that sort of messy communication is only bothersome for humans because writing code takes time and effort plus it's mentally taxing to change requirements several times. also boredom is a big issue. none of those challenges are relevant for a computer.

So it sounds like AI researchers should focus on replacing both sides - sounds like it would be much more efficient. (tic)

..what if it was two AI's deciding XD

But once XXQ has their own ChatGPT they can just communicate with each other and hash this out 1000x faster.

What if they replace "us" with GPT and one programmer to glue together the snippets it provides?

It can sit there and communicate with people endlessly. In fact, that is what it's good at.

Make the AI handle the conversation on both sides? No need to wait a few days for back and forth

You won't need this to-and-fro. GPT-X will generate both sides for you.

- Looks like they're using an auth protocol we don't support...

I've been working as a freelance software developer for about 5 years now, and my billing model is such that I only bill for hours spent writing code. Time spent communicating with people is non-negligible, which means that it has to be baked into my hourly rate. So I'm very cognizant of how much time I spend communicating with people, and how much time I spend writing code.

I strongly disagree that 99% of the effort is not writing code. Consider how long these things actually take:

> - they: we need a new basic POST endpoint

> - us: cool, what does the api contract look like? URL? Query params? Payload? Response? Status code?

> - they: Not sure. Third-party company XXQ will let you know the details. They will be the ones calling this new endpoint. But in essence it should be very simple: just grab whatever they pass and save it in our db

> - us: ok, cool. Let me get in contact with them

That's a 15 minute meeting, and honestly, it shouldn't be. If they don't know what the POST endpoint is, they weren't ready to meet. Ideally, third-party company XXQ shows up prepared with contract_json to the meeting and "they" does the introduction before a handoff, instead of "they" wasting everyone's time with a meeting they aren't prepared for. I know that's not always what happens, but the skill here is cutting off pointless meetings that people aren't prepared for by identifying what preparation needs to be done, and then ending the meeting with a new meeting scheduled for after people are prepared.

> - company XXQ: we got this contract here: <contract_json>

> - us: thanks! We'll work on this

This handoff is probably where you want to actually spend some time looking over, discussing, and clarifying what you can. The initial meeting probably wants to be more like 30 minutes for a moderately complex endpoint, and might spawn off another 15 minute meeting to hand off some further clarifications. So let's call this two meetings totalling 45 minutes, leaving us at an hour total including the previous 15 minutes.

> - us: umm, there's something not specified in <contract_json>. What about this part here that says that...

That's a 5 minute email.

> - company XXQ: ah sure, sorry we missed that part. It's like this...

Worst case scenario that's a 15 minute meeting, but it can often be handled in an email. Let's say this is 20 minutes, though, leaving us at 1 hour 15 minutes.

So your example, let's just round that up into 2 hours.

What on earth are you doing where 3 hours is 99% of your effort?

Note that I didn't include your "one week later" and "2 days later" in there, because that's time that I'm billing other clients.

EDIT: I'll actually up that to 3 hours, because there's a whole other type of meeting that happens, which is where you just be humans and chat about stuff. Sometimes that's part of the other meetings, sometimes it is its own separate meeting. That's not wasted time! It's good to have enjoyable, human relationships with your clients and coworkers. And while I think it's just worthwhile inherently, it does also have business value, because that's how people get comfortable to give constructive criticism, admit mistakes, and otherwise fix problems. But still, that 3 hours isn't 99% of your time.

In my extreme opinion, 100% of value is created by communication with people and problem solving. 0.0% of value is created by engineering.

This explains xkcd Dependency comic[0]; the man in Nebraska isn't solving anyone's problem in any particular contexts of communications and problem solving, only preemptively solving potential problems, not creating values as problems are observed and solved. This also explains why consultancy and so-called bullshit jobs, offering no "actual values" but just reselling backend man-hours and making random suggestions, are paid well; because they create values in set contexts.

And, this logic is also completely flawed at the same time too, because the ideal form of a business following this thinking is pure scam. Maybe all jobs are scam, some less so?

0: https://xkcd.com/2347/

Not just with external parties. This dance happens all over.

That's a cheap 1% boost!

Company XXQ to LLM once they figure their shit out: here is the endpoint we need. LLM: gives code. You: not involved.

Even within the N% that is more genuine coding and system reasoning; system reasoning is really hard, oftentimes requiring weird leaps of faith, and I also don't see a path for AI to be helpful with that.

Some random recent thing: "We have a workflow engine that's composed of about 18 different services. There's an orchestrator service, some metadata services on the side, and about 14 different services which execute different kinds of jobs which flow through the engine. Right now, there is no restriction on the ordering of jobs when the orchestrator receives a job set; they just all fire off and complete as quickly as possible. But we need ordering; if a job set includes a job of type FooJob, that needs to execute and finish before all the others. More-over, it will produce output that needs to be fed as input to the rest of the jobs."

There's a lot of things that make this hard for humans, and I'm not convinced it would be easier for an AI which has access to every bit of code the humans do.

* How do the services communicate? We could divine pretty quickly: let's say its over kafka topics. Lots of messages being published, to topics that are provided to the applications via environment variables. Its easy to find that out. Its oftentimes harder to figure out "what are the actual topic names?" Ah, we don't have much IaC, and its not documented, so here I go reaching for kubectl to fetch some configmaps. This uncovers a weird web of communication that isn't obvious.

* Coordination is mostly accomplished by speaking to the database. We can divine parts of the schema by reverse engineering the queries; they don't contain type information, because the critical bits of this are in Python, and there's no SQL files that set up the database because the guy who set it up was a maverick and did everything by hand.

* Some of the services communicate with external APIs. I can see some axios calls in this javascript service. There's some function names, environment variable names, and URL paths which hint to what external service they're reaching out to. But, the root URL is provided as an environment variable; and its stored as a secret in k8s in order to co-locate it in the same k8s resource that stores the API key. I, nor the AI, have access to this secret thanks to some new security policy resulting from some new security framework we adopted.

* But, we get it done. We learn that doing this ordering adds 8 minutes to every workflow invocations, which the business deems as unacceptable because reasons. There is genuinely a high cardinality of "levels" you think about when solving this new problem. At the most basic level, and what AI today might be good at: performance optimize the new ordered service like crazy. But that's unlikely to solve the problem holistically; so we explore higher levels. Do we introduce a cache somewhere? Where and how should we introduce it, to maximize coherence of data? Do some of the services _not_ depend on this data, and thus could be ran outside-of-order? Do we return to the business and say that actually what you're asking for isn't possible, when considering the time-value of money and the investment it would take to shave processing time off, and maybe we should address making an extra 8 minutes ok? Can we rewrite or deprecate some of the services which need this data in order to not need it anymore?

* One of the things this ordered workflow step service does is issue about 15,000 API calls to some external service in order to update some external datasource. Well, we're optimizing; and one of the absolute most common things GPT-4 recommends when optimizing services like this is: increase the number of simultaneous requests. I've tried to walk through problems like this with GPT-4, and it loves suggesting that, along with a "but watch out for rate limits!" addendum. Well, the novice engineer and the AI does this; and it works ok; we get the added time down to 4 minutes. But: 5% of invocations of this start failing. Its not tripping a rate limit; we're just seeing pod restarts, and the logs aren't really indicative of what's going on. Can the AI (1) get the data necessary to know what's wrong (remember, k8s access is kind of locked down thanks to that new security framework we adopted), (2) identify that the issue is that we're overwhelming networking resources on the VMs executing this workflow step, and (3) identify that increasing concurrency may not be a scalable solution, and we need to go back to the drawing board? Or, lets say the workflow is running fine; but the developers@mycompany.com email account just got an email from the business partner running this service that they had to increase our billing plan because of the higher/denser usage. They're allowed to do this because of the contract we signed with them. There are no business leaders actively monitoring this account, because its just used to sign up for things like this API. Does the email get forwarded to an appropriate decision maker?

I think the broader opinion I have is: Microsoft paid hundreds of millions of dollars to train GPT-4 [1]. Estimates say that every query, even at the extremely rudimentary level GPT-3 has, is 10x+ the cost of a typical google search. We're at the peak of moores law; compute isn't getting cheaper, and actually coordinating and maintaining the massive data centers it takes to do these things means every iota of compute is getting more expensive. The AI Generalists crowd have to make a compelling case that this specialist training, for every niche there is, is cheaper and higher quality than what it costs a company to train and maintain a human; and the Human has the absolutely insane benefit that the company more-or-less barely trains them, the human's parents, public schools, universities paid for by the human, hobbies, and previous work experience do.

There's also the idea of liability. Humans inherently carry agency, and from that follows liability. Whether that's legal liability, or just your boss chewing you out because you missed a deadline. AI lacks this liability; and having that liability is extremely important when businesses take the risk of investment in some project, person, idea, etc.

Point being, I think we'll see a lot of businesses try to replace more and more people with AIs, whether intentionally or just through the nature of everyone using them being more productive. Those that index high on AI usage will see some really big initial gains in productivity; but over time (and by that I mean, late-20s early-30s) we'll start seeing news articles about "the return of the human organization"; the recognizing that capitalism has more reward functions than just Efficiency, and Adaptability is an extremely important one. More-over, the businesses which index too far into relying on AI will start faltering because they've delegated so much critical thinking to the AI that the humans in the mix start losing their ability to think critically about large problems; and every problem isn't approached from the angle of "how do we solve this", but rather "how do I rephrase this prompt to get the AI to solve it right".

[1] https://www.theverge.com/2023/3/13/23637675/microsoft-chatgp...

> I'd tell it the error, it'd give me a different way to import, only leading to a new import problem

It's dataset is thousands of blogs posts and stack overflow questions about this very thing, of course the autocomplete engine is going to predict the next response be "another way of doing x".

You can also ask it to "continue at this line XZY" and it will not give you the whole thing again, only the new continuuation.

"Please continue without explanation." Usually works for me.

I don’t understand the high level language to machine language comparison with AI. HLL to machine language is translation. We hardcode things. This literal translates to this thing. Machine language has it own mind (figuratively) and it’s not doing translation. It can put some silly bug by misunderstanding the requirements which may cause a billion dollar software meltdown. And who is going to be responsible for that?

The more black box programming becomes the more dumb human programmer gets. There will be stagnation. There won’t be any new “design patterns”.

Yup. It kept suggesting me properties in flyway (Java lib) which doesn’t exist. It actually threw me of the track and I made a mental note of programming without GPT.

This rant from a little while ago soured me on this quote: https://news.ycombinator.com/item?id=34940148

And then some guy called Kepler invented a new kind of telescope.

(And we all atarted writing more quantum algorithms.)

This is already how automotive companies work. They are huge organizations which do four things: marketing, financing, design, and requirements. The supplier management and project management all fall under requirements management and enforcement.

I firmly believe that we should be studying model analysis and using that to create a field of peompt engineering. Both from a security standpoint and a productivity standpoint.

Tests and type signatures. Hopefully soon, dependently typed signatures.

> There will always be an artisan making the first version of anything.

Until we reach the bootstrap point (the singularity?), i.e. when the GPT-making machine is GPT itself. Or maybe we're still one level behind, and the GPT-making machine will generate the GPT-making machine, as well as all the other machines that will generate everything else.

I’ve been working with copilot a few months and the biggest surprise is how it has led to much better commented code. I used to comment tricky code to explain it. Now I comment trivial code instead of writing it. Often two lines of comment will get me 10 lines of copiloted code, faster than I could have typed it and with good comments to boot.

I predict there will be an explosion of productivity and small scale entrepreneurship. These tools are going to give so many smart but technically unskilled people a path towards realizing their ideas and vision.

Exciting times

> can be uncomfortable for people to build their livelihoods upon

Absolutely. Not everyone can be consistently creative, and without a large enough financial buffer, it's a recipe for disaster.

Great point. That's one reason I'm increasingly a single-issue voter focused on UBI.

> But it's lightyears away from translating business problems into actionable solutions.

Is it though? Have you tried feeding it business problems and working through to possible solutions paths? Have you roped in additional external information (via agents, tools, vector search, etc.) during that process? I don't see why the model wouldn't be able to translate a lot of business problems into solutions paths.

Solve once for each number of fire tiles n.

If the parent's description of the problem is correct, then imagine this:

You have a solution of length 6, no fire; Solution of length 4, one fire; Ok sure you prefer the no fire one.

the score for the paths is 6 and 13, respectively

Your algorithm works! But as soon as you have a solution of length 10 (or some length bigger than the length you want), a* still prefers that to the solution without fire - but the answer must be less then or equal to six steps

You can modify to make fire cost 1.1. Now if you find a solution of length 6, you know it must be correct (it minimized the number of fire squares and ended up with a length six solve). But if it's not length 6, you need to increase the cost of fire and run again if there was any fire in your solution.

At a glance, it might be OK that way, and I would give it the gold star. It's just unintuitive to make the leap to "apply a cost to the total length of the path" as a way of expressing preferences among distinct categories of path.

Implementation of the categories as completely independent paths falls out of the clarified problem definition directly. It's really in nailing the specification that the problem is hard, i.e., even with GPT we're still programming.

Yeah, I'm not really that familiar with pathfinding, but my naive take is that you actually want 2 scores to rank on rather than making everything implicit in a single cost factor. You have a movement cost and a preference cost. The path needs to suffice the movement budget, but you want to optimize based on preference score.

Honestly one of my favorite early applications of AI was as customer service. The CS people I talk to always seem pissed with something.

One conversation:

Me: "Hello, I'd like to ask why all the loyalty points from my MILES card is gone."

CS: "Sir, it says here that you upgraded your MILES card to a SMILES card. If you did not request a points transfer, they are gone."

Me: "Okay, how do I do that?"

CS: audible eyerolling "You should have done that while applying for an upgrade."

Me: "You can verify my details for both, right? Can't you transfer the points over?"

CS: "Ugh." Hangs up

Whereas AI would always politely answer questions, even the dumb ones like this.

> quite a contrived definition of average

Sure, maybe an argmax mixed with an RNG isn't really an average, but some would say it's quite a contrived definition of forming an opinion.

what kind of unit tests are these? is it `check_eq(add(1, 2), 3)` or "check for possible exceptions, cover edge cases, test extremes of this super important db function"

write addition python code

Are hallucination is a systemic for-ever problem that will not be solved, mitigated or in akne other way rendered inconsequential?

Also, having conversations about things you don't understand with a machine, where you don't have to keep up social decorum and can ask the dumbest questions should help a lot with improving the decision making of non-technical personel

Have you tried giving it a skeleton example of said undocumented data format? I've created some arbitrary ones and asked it to parse them, and it succeeded.

>It will be a long time (if ever) until a ML model will be able to handle these situations (and I hazard a guess that most of the worlds active code is something akin to this).

ChatGPT can do that right now. Just provide it example data in the input and it can extrapolate the format and interact with this abstraction (i.e. describe the format, write code to it, etc). LLMs don't just remix data it has seen before, they perform in-context learning. This means abstracting out patterns in the input and then leveraging it in generating output.

Most CRUD apps in enterprise settings relate to something in the real world. E.g. ordering systems, warehouse management and so on.

The hard part here isn’t really the coding - but understanding the business logic and getting it out of the customer what they need.

Often the customer hasn’t even got a good enough grasp on their own business to be able to formulate what they need.

In the short term this ai tools will make the programming part easier but the planning part is still hard.

> Especially when a higher-ranking person comes back from vacation and says "no, everything you nailed down in the last two weeks is completely wrong".

Yes, and at some point this high-ranking person is fed up with this now-inefficient use of time and money enough that they will just sort this out using an LLM tuned to handle this situation better if not today then tomorrow.

Maybe they will pay someone to coach them for a week how to “talk” to LLM, but other than that the one who gets paid in the end is OAI/MS.

HN echo chamber. Generally the better/best programmers hang around here; your day 2 was probably better than many coders hope to achieve in their whole lives. It is replacing people already; I personally know about 10 people who have been fired or assigned to a completely different position because gpt did a faster and better or equal job. So ‘not anyone’ is simply nonsense; I am only one person, there will be many many more who see the same thing. Of course they are not told they are replaced by ai when fired, but their managers or more skilled colleagues know.

I do agree that there is no boring crud; that’s why gpt or no code tools are not good for full solutions (yet), but it’ll get there I am sure.

"predicting the next word" sounds trivial until you realize the value and complexity of "predicting the next word[s] by a world leading expert in a particular domain".

And the next iteration of ChatGPT will likely generate a better contract because your interaction with it will be used as training data

So you write the unit tests yourself to confirm the code you say you can't understand is correct? That's an interesting approach. But you'd probably need more tests than usual to gain confidence, so you are losing efficiency there (although the ceiling-raising nature of it is interesting).

What happens in production when there's a bug in the complex code you punted to GPT? How do you debug?

  > You meant "expand massively" i think. 

Nope, I meant what I said.

> There wont be any unprecedented mass layoffs

Baghdad Bob strikes again.

  > this is nothing new or unprecedented

I don't even think it's useful for the incompetent. I do think the incompetent think it's useful tho.

Care to place a wager where I give your mythical unskilled team the best AI available today against me without AI and we’ll see who can solve a difficult engineering problem? Heck, even a moderately skilled team.

Sorry no. AI is impressive but I’ve given it very precise prompts where I describe exactly what I want it to do because I’ve already solved it and the solution it generates is complete and utter horseshit because it requires context that’s too difficult to communicate and a deep understanding of the business and technical aspects of that business. Similarly, novel ideas are not things it knows how to implement.

If you have a counter example I’d love to see it because my experience seems to line up pretty well with other reporting of where the limits of it lies - ie it can regurgitate solutions to solve problems but struggles to provide solutions and correct implementation. In fact, trying to find the problems is itself even harder sometimes because the way it solves things is simultaneously not a good coder and the approach it takes isn’t one a human would and thus it takes extra effort to figure out what path it’s trying to take and where it made a mistake.

As an example. Try to get ChatGPT to implement the server-side implementation of R2’s ListObjects (or heck - in any language / platform you choose, implement that). It’ll make really bad bugs like reading in the entire dataset into memory, not applying the delimiter properly in really subtle ways etc etc. basically, it can’t even do a usable first draft. Just don’t use go because I suspect it’ll cheat and just regurgitate minio

Ok, but it has all this information already. So why is this surprising.

A real test of it's abilities would be synthesizing a NEW type of nuclear reactor.

I couldn't get ChatGPT to do Wordle. I don't have access to GPT-4. See if it can do that.

I just adore the hubris on full display here to say what one of the world's best computer science educators has to say is irrelevant.

If your engineers are actually engineering then yes, really by all means keep them and integrate GPT in workflows as is suitable.

Yes, for sure. Some applications of procedural texture primitives (like Perlin Noise) that I wasn't super familiar with and for example "quaternion" which I never heard about before trying to write a game.

Huh? I literally just gave you an example of tech that automated away what 90% of programmers were doing.

I mostly work in Clojure and I've noticed this as well, it is usually more efficient to just write it myself if I know what I want to do. However for a language or stack I don't understand well where I just need something quick and dirty it really shines... I had to work with a JS visualization library and got it to write what I needed over 10-15 iterations, much faster than if I actually had to learn the library. General programming knowledge sufficed for noticing things that didn't look right and since the output was visual that helped to sanity check the output as well.

I too like science fiction. People keep acting like it will be easy to bolt on things like eliminate misunderstandings onto LLMs and quite frankly I would be incredibly surprised if that happens any time soon.

Extending this analogy into a question: Could the polar bear community eat enough expert food providers that their quality of food and eventually overall health declines?

I suspect (and sort of hope) they're close to hitting a local maxima

presumably they've already fed it all the code in the world (including a load they probably aren't licensed to)

> you should be concerned about the rate of progress

Kind of agree?

On the one hand we don't even have a roadmap toward reliable AI.

On the other, if we ever plug an LLM into something that has memory, acquires experiences, does experiments, observes the outcome and adjusts its worldview in response, consciousness might fall out of that. And writing good code might not even require consciousness.

> their monkeypatched

You mean, like almost every outsourcing company pops over? So the type of code that infests companies who hired some sweatshop to do ‘some simple crud’? What’s the difference? Can you see the difference? Besides the gpt code will be far better commented as comments come for almost free with gpt while humans hate writing them.

"Hey GPT-X: Can you refactor the codebase in gpt@monkeypatched-crap.git for me? Preferably in the style of gpt@crappycrud.git that I worked on last year."

I've been a programmer for 23 years now. In all these years every year was the year of no-code tools.

And you know what? We went from having actual no- or low-code tools (UI builders, forms in Access and FoxPro etc.) to zero no-code tools worth a damn [1]. There was a brief dream of Yahoo! Pipes in mid-to-late 2000s, but it's dead as well.

[1] Except some applications like Unreal Blueprints and similar node-based tools in audio and graphical software

I'm still waiting for the no-code tools that can replace me, the API Glue Coder.

They've been promising those since the early 2000's, but I'm still employed.

Some stuff has been automated by Zapier, IFTTT and the like, but most of the systems I'm integrating with don't have public APIs.

Except it isn't and it won't be until 10 layers of management learn what no-code tools are and why they should want them.

> If all you're doing is very simple crud apps and transforming API responses,

I think all of us here conflate simple with easy. It's simple in theory yes - you get some JSON from service X, maybe tweak service Y that talks to X and then feed it into some front end. In practice even very experienced engineers can take days writing or changing a simple end point or some front end because unclear requirements/bugs/micro service hell/unclear existing code/etc etc.

If it was that easy the pace and quality would have been much higher than what I'm seeing in tech companies.

But obviously increasing avg and sr programmer productivity by many x implies many fewer jobs for programmers. That’s the point we’re interested in.

The fact that we’re even having this conversation should concern you. Move the goalposts if you want, but the rate of progress should concern you.

That's why I said it was unpredictable, in both directions.

Who? Crying wolf makes sense to discredit an individual but not a whole argument. Almost everything is being predicted by someone at any given time. If your criteria for predictions is “no one can have made a similar prediction and been wrong in the past”, then you’ll disbelieve all predictions.

And seriously, how many people were actually saying “WolframAlpha will destroy a huge amount of programming jobs”?

Except Watson and Alpha weren’t useful out of the box to everyone. They weren’t the fastest growing app of all time and couldn’t even remotely play that way. ChatGPT isn’t hype because it is so useful — it’s already on the “Plateau of Productivity”.

But it looks like an exponentially steep climb from here. indefinitely

I think everywhere except HN the expectations on Watson’s and Wolfram’s second seasons where even more inflated

Demonstrably untrue, it’s taken up semi-residence in everything from oped pages to boardrooms since the New Year. Welcome to the mid singularity, my friend.

The raison d'être of COBOL (now Cobol) in the 1950s was that "there is no need for a developer at all". Managers can produce their own reports.

How did that turn out? A whole profession was created.

The thing that comes closest to "no developer needed" is Excel. But you really need someone who knows programming if you want a reliable, robust product, even in Excel.

It's astonishing to see the goalposts move so quickly. The cope of "well, okay, it can do that, but that's not even the hard part!" when just a year ago this entire product was almost unimaginable.

>Additionally, even if I concede it is an argument solely on authority, just because an argument contains a fallacious point doesn't make it untrue

Notice how you also conveniently sidestepped my arguments about why it's also untrue (on top of containing a falacious point).

I think we all started replying to a sibling comment that quoted from Dijkstra and we got it threaded wrong.

"Computer Science is no more about computers than astronomy is about telescopes” - Edsger Dijkstra

Does a chess engine “understand” the position? If you define “understanding” as the ability to think like a human then Stockfish is obviously much worse at that. If you define understanding as the ability to choose the correct move, then Stockfish understands the position much better than any human.

The point being, you can choose to laden the word “understand” with the meaning of human-like thinking, in which case humans will always be superior by definition. Or you can choose a “many ways to Rome” definition of understanding that is purely focused on results.

Large language models understand language in their own way. Currently their results are inferior to humans’ but one day the results may be superior.

Even view it as a simple probability model, you don’t need a million Python repos. The massive amount of English text + 1,000 repos + your codebase is very powerful. You can see this because you can make up a language, give it some examples and it’s surprisingly good.

No you obviously don't lol

Have you ever worked at a software firm of greater than say 30 people? Doesn’t resonate with my experience at all, and the 30+ people are there not just to write code.

Everyone's focused on writing code - is the code even needed when a good enough AI exists? How many of us are writing code to extract 10% more efficiency out of humans, if they go so do we.

Also if software development does survive, it's going to look very attractive to all the other unemployed people.

> Makes me feel like GPT is marketing to the incompetent or something.

Absolutely. The common constant I can see in people who are really blown away by GPT's performance at [task] is that they are bad at [task].

Programmers who describe their job as copying from StackOverflow think it's great at coding. People who don't read fiction think it's great at writing fiction, and so on.

Exactly, we know how much code gets written per programmer hour, its in the single digits on average. Speeding that up wont make a big difference.

> Not once was programming something that was a time sink.

Can you please expound on that? Do you mean not hard as in comparison to something else?

You know the shoeshine boy indicator story [1]? That's the vibe I've been getting with ChatGPT lately, I have multiple old high school teachers with 0 computational background who hardly ever spoke about ML before posting regularly on LinkedIn about ChatGPT the last couple months.

The part that gets me is they aren't just aimlessly making posts, they're getting involved with webinars targeted at educators in their respective topics, speaking at regional events about the future with ChatGPT, etc.

One of them was a really excellent teacher but like this dude absolutely does not have any qualifications to be speaking on ChatGPT, and I hope it hasn't actually changed his teaching style too much because I'm having trouble imagining how ChatGPT could've fit in well with the way he used to teach.

Don't get me wrong, hype often surrounds something legitimately good, but I think ChatGPT is being taken way out of context in both the ML achievement it is and in what things the tool is actually useful for. I guess it is easy for a layperson to make mistaken assumptions about where the puck is going when they see what ChatGPT can do.

[1] "The story took place in 1929: Joseph Patrick Kennedy Sr., JFK's father, claimed that he knew it was time to get out of the stock market when he got investment tips from a shoeshine boy."

Soon, a lot of people will realize that the puck doesn't travel in a straight line. Eventually, it will veer to the right in a logarithmic fashion. When it does is up for debate, but - in my experience - it always happens very short of where the hype claims it was heading.

That's a comforting perspective, I hope that you're right.

I got into and out of Bitcoin back in 2010 when I was still in high school. Even then, I thought and still do that crypto as a whole is a complete ponzi scheme with little real world utility.

I feel completely differently about LLMs; I'd say we're closer to 2007 when the first iPhone was released. I believe LLMs will become a part of our day to day lives at a level that crypto never came close to.

Again? Last time it ended in a long winter.

And horse carriages have some serious advantages, maybe even will make a comeback. :)

I’ve got a computer in all of my light switches. There’s a limit to this, but I’m not quite sure where it is.

Isn’t that true of any economy? Think of how many people are employed in general. How could this number of people have been employed 200 years ago?

I wouldn't count on that, you can call a self driving taxi right now in Phoenix.

I haven't messed with it much since I find the process for the 'good one' (Midjourney) annoying (go onto a Discord channel, type your request in public for a bunch of people, wait a while, hunt for it amongs the long channel of requests, etc).

I'm assuming the process has gotten better since, but I don't know. I'm mostly just using free vector art and simple colors/shapes or whatever simple things I can make in Blender for my art still, in part because there's such a backlash against using any A.I. art right now.

Most of it is judging by what people have been saying in groups online. Some people have found it very useful and use it extensively, like for their board game art.

It doesn't even have to get 100% of the way there (for coding games based on rulesets). Even 75% would probably save me a lot of time and allow me to find the energy to close the gap as opposed to not even starting since I have so many other projects going on.

Your brain is analog. Trying to emulate this with a digital computer is bound to come with some computational cost.

The thing was when pocket calculators came out they were expensive to get ahold of. Like 500-1000 bucks for one (in 1970s terms that is a lot). This sort of NLM is effectively free. All you need is an account and the cell phone you already have. This is disrupting classrooms right now. Everyone I talk to that has a kid is saying their kids are using it for coursework. I get why teachers are 'oh no...' as of right now it is exploding on them. They have not had time to digest it. Unfortunately at this point chatgpt is like an reporter summing up information it has no idea what it is talking about and putting it into nice prose that looks good. So while in your area of expertise you can spot out the issues. But you flip the page and it is on a different subject it will be tough to spot out the errors. Simply because you do not know and attribute expertise they do not really have onto it. This NLM is that but turned up to 11.

"where the puck is going" is something to consider and we will 100% get that wrong, but right now this thing is creating waves and making issues now.

> simply know firsthand (i'm old, i have manager, cto, ceo friends who I go golf and play squash with) that people in data entry and programming have been let go in the past weeks because 1 person could take over their work using the gtp/chatgpt api's and do their work faster with less errors. I am recommending the same in my company as a lot of my colleagues are doing nothing anymore as the skilled seniors are doing it themselves with gpt now as it's faster, less communication etc. We feed jira issues into gpt and it generates code; we review and refine or fix ourselves. It works much much faster and with better results.

This isn't software engineering work, this is 21st century data entry with some code. This is exactly the type of menial work that should be automated by AI.

If you have small self contained problems like map X -> Y then sure, ChatGPT will be sufficient. Where I disagree with you is calling these jobs "programming" jobs. These are the type of tasks that should've been written in a transform language like JOLT. This shouldn't even be code.

> With humans this is a painful and slow process, especially with people who are fast and loose (broken education seems to made many of those graduate just by cheer production speed & volume instead of quality; gpt can do that better too...).

Humans suck at repetitive menial tasks like this. It's not education's fault.

How does this work from an IP perspective? Aren't you feeding OpenAI and Microsoft with your confidential information?

Also, what license is the code under when you get it back?

I'm impressed by the talking dog because it's a dog that can talk, not because I think it's a great orator.

When I say singularity, I mean “changes the nature of human life irreversibly and to a greater degree than any prior technology through a rapid progression of self-reinforcing growth.”

That rapid progression can be modeled with an exponential growth curve, like Moore’s law, even though nothing material can have a sustained exponential growth. Regardless of how the curve is modeled, the steepness is such that it serves as a step function in evolution.

With that clarified, there is first the question of “is the technological progression going to level off soon?” And I think the answer is no. The second question is, “how are we going to deal?” And the answer to that question can only be addressed once we answer the question: “what kind of world do we want to live in?”

I disagree. GP, by their statement and appeal "I've worked on adtech, crypto, fintech, gamedev, startup founder, ...", implies that he has worked on complicated software issues, and that he thinks GPT is a promising replacement for developers working on those problems.

GPT-3 is 3 years old, not a few months.

we don't know what that jump means, did they increased model proportionally, or slapped some projection layer with quality degradation?..

Few years, yes. I’m with you “the change is coming” but we still need to transfer millions of tokens in and out to cater for context and out of repo intricacies.

Hmm. I see the singularity as a recursive step change; the last step where the average slope becomes vertical.

I’m not a singularity believer (singularitist?); from the perspective of 1000 years ago we’re already at the point of infinite progress in zero time. I think individuals, the culture, and the species adapt to accelerating progress, and I intuit, maybe wrongly, that Gödel‘s theorem means that technology will never become runaway and recursive.

But I think that’s what people mean, more than just a step/paradigm change like the internet.

Yes, we don’t all live in the US.

I think it is better to assume that we are at the beginning of the s-curve, not the end.

Seems very man of these here for some reason, trying to find whatever reasons and ways (gonna be licensing mostly) to spread FUD.

If increased productivity equaled job loss, there would be two programmers alive today, doing the same job as the fewer than 10000 programmers using punch cards as we entered the year 1950.

A lot of projects today are not even greenlit because they would be too expensive to make. For instance, there are a lot processes in almost every country that require you to file paper forms, even though we have had web forms and databases for 25 years. This goes even for rich countries. If one programmer is able to do the job of 5 others, we will probably have 5 times as many systems to tend to now that businesses and institutions can afford them.

> Companies are already bloated, imagine when they realize one overworked highly paid senior can replace 10 juniors.

Yep. This is where I'm at in terms of personal armchair predictions of the future.

I expect the labor market will be tough for more junior software engineers in the coming years. This might indeed cause backpressure in the supply of new grads/new labor force entrants in this family of fields ("software development").

However, the "highly paid senior" is only around for so long before achieving financial independence and just not working anymore. Then what? The company didn't hire juniors because the "highly paid senior" did all the work. Whoops. Now the company lacks the pipeline of people to replace that senior.

It'll sort itself out in time, but the next decade will be interesting I think. Some companies will realize that they must make investments into the future of the labor force and will do better in the longer term. Other companies might indeed "fire the juniors" for some short term gains and find themselves lacking replacement staff later.

> Companies are already bloated, imagine when they realize one overworked highly paid senior can replace 10 juniors.

That is already possible without AI and has been the case for a long time... the issue is nobody will stay to be that highly paid senior running entire projects because at that point you can just run your own shop and pocket the full profits.

Fixed pie fallacy. More likely, there will be 5x as many apps / companies with just as many jobs available. And the cost of everything will go down, except truly scarce things like Manhattan real estate.

This was already the case 10 years ago.

Except, there was no AI, but an alternative called an offshored development center. You would send your spec and design document and get, via email or FTP if they were really cutting-edge a number of files that would sometime compile and even, according to the legends, actually work. The way this tech worked is that you generally had to wait overnight for your spec to "mature" into code.

Some places figured out they could hire local engineers for about 5-10x what they paid for this "offshored development center" tech and get better results.

I think this fear is unfounded because history shows this is not the case. We will adapt to the new level of productivity and our goals will adapt accordingly. What we are expected to produce will adapt. You were able to pump out 4 solid production grade pull requests per sprint? Then the expectation increases to a single dev being able to pump out 10. The company's ambition will grow as a result of the newfound efficiencies, and management will continue to request things that cannot be reasonably delivered on time with the people and tooling we have.

I don't know if that's going to be the case - companies can never have enough software and typically they just go until the budget runs out as the software is never "done". I think being able to build 5x the software with one dev means that each company is going to build 5x the software.

> imagine when they realize one overworked highly paid senior can replace 10 juniors

This already happens, the market is just not very efficient about it, e.g. a highly paid senior dev is not working at a company that only needs 2-3 developers, they're working at Google with 100's of devs.

How much more efficient is programming in Python with modern tools vs assembly? I would bet more than 5x

> making a single programmer do the job of 5

I mean, I already do? And for totally mundane and benign reasons. This has been my experience in this industry for the last 8 years or so, though my first 9 years I felt like the pace was maintainable.

Do more with less. It's so common to come across situations where so and so left, their position won't be backfilled, the targets don't adjust to compensate for the productivity hit, and we can put up or shut up.

I'm kind of on the fence with this one. As someone who does programming at work,I don't want to be partially replaced by a prompt, however there are also lots of sectors, where the problems are big and solving them could help a lot of people but money is an issue,so being able to access resources on a scale of large tech companies would be amazing.

You're not thinking that companies will not just spin up 5 projects, so 5 programmers produce a notional 25 person's worth of work. And hey, maybe they sack the expensive old guy and the AI spend isn't so great. Seems like a win.

Wouldn’t this actually create more demand for programmers? More businesses can exist that have a need for software. To date every advance in programming efficiency has resulted in more tech, not less.

Additionally there’s the math behind it. If Company A fires 50% of their staff because AI lets the remaining 50% work at twice the productivity then how will they compete with Company B that keeps their staff and now gets 200% efficiency?

The math is in favor of getting more, not fewer, developers.

If you can have one programmer do the job of 5, then you will be defeated by companies using 5 programmers to do the job of 25.

Also, if your one programmer dies you now have no programmers and loss of all institutional knowledge, whereas the other company can lose several programmers and still be OK. There is value in having redundant programmers.

That would be awesome. We have a never-ending list of things to do and not enough time to do it all. What you're saying to me is that we can get through our list of priorities even faster, and stuff won't continually rot at the end of the list.

If as GP says AI could automate 1% of a single programmer's job (the boring part where you write code), then how on earth can you derive that a single programmer could do the job of 5 with AI? It's completely illogical.

Companies were bloated because of the profit potential of tech and organizational dysfunction.

AI wasnt needed to cut down on bloat - some combination of a few companies reaping the majority of the profit and reduced dysfunction is enough.

Companies will continue to hire even more people. Their single point is growth.

If one can go the job of 5 - they revenue per employee will increase.

They will hire even more employees.

Yeah, but they would then just start 10 times the number of projects at once and watch the majority of them fail.

We should stop thinking about the trade-off as between developer time and CPU time. The CPU is an inanimate object which doesn't mind pushing around more electrons. What we're really throwing under the bus when we optimize for developer time is the customer's time.

If an inefficiency saves a developer 10 days of work, but results in an operation taking 100 milliseconds longer, and you have 50M customers who do that operation just one time, then you've wasted ~58 customer-days.

Good question. Why don't we pit one of today's Python programmers against an IBM VS assembler programmer on an IBM 360 system circa 1960 and see how far each gets in a week?

Can't believe companies are still single-threaded in 2023.

Even in the gaming industry. Typically you have people developing an engine, common frameworks... tools that downstream work to lower branches - now I can just type to chatgpt rather than go through requesting/reviewing, see quicker where I mis-designed my "framework" etc... I am afraid it's gonna be not great for junior engs all together.

Every org has varying level of engineers. This technology will make cheap grind, well cheap. We see the progression. With the speed of changes it seems we should all be worried. (as why does it matter despite being last we fell a year after)

Yes, this is also why senior engs get payed so well. Actually if you are junior dev you basically cost money, imo. However a lot of companies hire those in hopes they will make their career and stay longer - especially startups do that, as they can slide on the company culture hook way more. Also they need them as senior engs require equivalents of "secretary" to handle less import things.

I don't mean to sound mean, senior devs are also secretaries of their cto and so on.

Tell that to SAP, Oracle, ServiceNow, or a dozen other enterprise software vendors.

> you are losing traction and your competitors will win

i mean, unless your competitor produces order of magnitude less bugs than you, how can this be true?

Don't forget customer's battery

So we just have to figure out if developer-hours or customer-hours are the tighter bottleneck.

I think dev wages will stagnate across the board. I think the simple existence of the fear of being replaced by never-tiring, always-working AI will subconsciously prime devs to be willing to work for less. Devs have been in a market with a significant shortage of skilled labor; can we say that remains true after GPT hits the mainstream even more than it already has?

Agriculture is still automating and the population has increased what, 4x since then

> How long would it take a good assembly programmer to implement a CRUD web server connected to a database?

You know you can call import functions and call libraries in other languages than python? If everyone was programming in assembly then there would be plenty of libraries to make database calls or make web servers in assembly, and there would be plenty of tutorials online that you could copy and paste to get things going, meaning it wouldn't take much work at all. It would be more work, but not orders of magnitude more work.

an assembly programmer wouldn't write a web server connected to a database, they would implement a tui over tty, and it would be faster.

But that’s never happened in the past. Why should it happen now? The Industrial Revolution is used as an example because it was the biggest spike in productivity, but the general trend has been the same since the invention of tools. Agriculture, another perfect example, lead to others having time to produce things instead of hunting/gathering. It’s easy to grasp with the agriculture example that “unemployment” wasn’t even really a risk.

Sure, there will be niche sub-industries that will be erased by LLMs, and people who have those niche skills will suffer. This has always been the case with technological advances. And always, it has not disrupted the economy.

I dunno, I feel like we've been trying to find new places to put computers for a couple decades now, and the effort is kind of losing steam. Every week there are threads about how useless a lot of these efforts are.

>In the 80's and even the 90's everyone said the same thing, "Why do I need a computer? I can do everything I do already without a problem?" Well, turns out with computers you could do 12 more things you can never considered

Yeah. Also, unfortunately, it turns out those people in the 80s and 90s got it right. They didn't really need a computer - they'd better off without one. But as soon as we got them, we'd find some things to use them for - mostly detrimental to our lives!

It is different this time. In the past automation effected some domains more and some domains not at all. People moved to those other domains. AI can run all the domains humans do and more that they can't.

https://www.youtube.com/watch?v=7Pq-S557XQU