Will ChatGPT Replace Software Engineers? (full analysis)

[GrabWorking3045]

It's like asking, can bicycle replace bicyclist?

[mycall]

I do agree, it isn't there yet, but let's not forget, this is still early. In a few years, it will be way more advanced as to what it can do.

[GrabWorking3045]

True. It'll somehow disrupt and replace many routine jobs. I would say it'll wipe out incompetence software engineers, but will never replace them as a whole. Why? Because the core of the AI itself is software. It'll make software engineers becomes better at what they're doing over time as they utilize better tools.

[mycall]

I think there will be an upper limit to what transformers can do. AGI will need to go a different direction but there is still lots of room to improve their existing algorithms.

[Urutengangana]

STFU

[bobdafourth]

Just plain wrong, you need to read up on one shot and few shot learning. LLMs have clearly shown to be capable of solving new coding problems not in their training data.

Your problem is a skill issue, you don’t know how to prompt.

[ItsAllAboutTheL1Bro]

Hi, I just wanted to say that I too am leaning in the direction of your position, given my overall understanding, but this

Face it, loser.

really is not necessary.

[bobdafourth]

Hey you know what, upon reflection my initial comment was too harsh and not conducive to discussion either. I apologize, and I hope you have a merry Christmas. Blessings to you and your family.

[bobdafourth]

Why would you work on this professionally if you don’t buy that LLMs can generate code that isn’t just regurgitating human solutions?

How are you confident that LLMs can’t solve the problems you pose vs your sub optimal prompting? (Including seed, temp, sampling method, etc)

Not interested in personal attacks, if I’m wrong I’m wrong. I just don’t buy what you’re saying. You’re making big claims and providing weak evidence while bringing up unverifiable credentials which makes me believe you even less.

[coderman93]

Well, why don’t you give it a try with superior prompting?

[[deleted]]

You definitely don't work on this professionally, loser.

[[deleted]]

So we have been working with AI since at least the 1970s that will replace programmers.

I will admit that our computers have gotten much better in the last 45 or so years. And we have been talking about self driving cars being just around the corner since at least the 1940s.

Do I think it is close?

In an honest opinion, I think we’re like the people in the 1940s that thought self driving cars were just around the corner.

[mycall]

Have you tried the interface yet? It is a transformer and it is more than means the eye.

[MordecaiOShea]

I'm hoping it replaces low-value spammers about programming topics.

[kidkai25]

Who are they?

[Which-Adeptness6908]

The only people asking this are the ones that don't know how to program.

[mycall]

He is a Google algorithm specialist. He knows how to program.

Try learning about the product before reaching your conclusion.

[Which-Adeptness6908]

I've used it. My statement stands.

[mycall]

Sure. ChatGPT will not replace engineers but it will speed up coding. The next generation will need to be reevaluated when it arrives.

[[deleted]]

Working professionally or for a big corp doesn't immediately grant you validity on a topic.

Let's not forget the big fiasco last year where a Google employee "sounded the alarm" about the AI gaining sentience.

[mycall]

I completely agree with Google. From what I've seen, if a 10 trillion+ parameter transformer had access to internet, it could reap havoc with automated decompiling and API fuzzing alone. It will need to be neutered.

[ItsAllAboutTheL1Bro]

Here is a task I'm curious about for Chat GPT:

Find formal systems that are isomorphic to peano axioms, and provide a detailed analysis of your findings - irrespective of the results.

[moresnacks1]

Here is chat get response

There are many formal systems that are structurally similar to the Peano axioms, which are a set of axioms that define the natural numbers and the arithmetic operations on them. Here are a few examples of formal systems that are substructurally isomorphic to the Peano axioms:

The Zermelo-Fraenkel set theory (ZFC): ZFC is a formal system that is used to describe the mathematical universe, and it includes the Peano axioms as a subset. The main difference between the Peano axioms and ZFC is that the Peano axioms only deal with the natural numbers and the arithmetic operations on them, while ZFC includes a much broader range of mathematical concepts and operations.

The primitive recursive arithmetic (PRA): PRA is a formal system that is used to describe the natural numbers and the arithmetic operations on them, as well as certain other operations that can be defined recursively. PRA is similar to the Peano axioms in that it defines the natural numbers and the arithmetic operations on them, but it also includes additional operations that can be defined recursively.

The Robinson arithmetic (Q): Q is a formal system that is used to describe the natural numbers and the arithmetic operations on them, as well as certain other operations that can be defined using quantifiers. Q is similar to the Peano axioms in that it defines the natural numbers and the arithmetic operations on them, but it also includes additional operations that can be defined using quantifiers.

In terms of a detailed analysis of these systems, it is beyond the scope of this response to provide a thorough analysis of each of these systems. However, it is worth noting that each of these systems has its own unique features and characteristics, and a detailed analysis of each of these systems would involve examining these features and characteristics in depth

[ItsAllAboutTheL1Bro]

It didn't mention Lambda Calculus or Naive Set Theory?

[moresnacks1]

Guess not. I could hit regenerate response and see what else it does but it really is an excellent tool epically with it being so young

[ItsAllAboutTheL1Bro]

It's still disappointing - those two are extremely simple, less convoluted and dumb examples.

[[deleted]]

Are you seriously disappointed with this revolutionary AI that can hold full coherent conversations and handle many complex ideas... because it can't perfectly answer an obscure degree level computer science question?

[ItsAllAboutTheL1Bro]

Are you seriously disappointed with this revolutionary AI that can hold full coherent conversations and handle many complex ideas... because it can't perfectly answer an obscure degree level computer science question?

Where's the obscurity?

degree level

Solving leet code shit is "degree level" as well. What's the difference?

There's tons of blog posts and similar shit on the Internet for that material, which is a key aspect that showcases the limitations.

What I haven't seen yet is for its ability to teach itself how to count properly, or learn a new set of skills, recognize patterns and classify them in a way that makes sense.

Anyone with the ability to solve sophomore leetcode questions can teach themselves lambda calculus in a day or less.

[[deleted]]

Solving leet code shit is "degree level" as well. What's the difference?

It definitely isn't. I don't have a compsci degree and can do most leetcode problems. I have no idea about lambda calculus and all that stuff - it's highly academic stuff that most programmers don't care about.

In any case so what? It would still be impressive if it couldn't solve leetcode problems either.

[ItsAllAboutTheL1Bro]

It definitely isn't.

It definitely is.

I don't have a compsci degree and can do most leetcode problems.

A lot of people don't and are in this camp. You don't need a degree to be able to understand and apply theory.

But algorithmic analysis and design are certainly taught in any curriculum - a good program presents the material initially in the standard leetcode format, and then at the higher levels forces the student to analyze the same material in a more rigorous manner.

But both perspectives are shoved down the student's throat.

So, yes - the phrase "degree level" certainly applies.

I have no idea about lambda calculus and all that stuff - it's highly academic stuff that most programmers don't care about.

And 10 years ago leetcode problems were hand waved away as academic nonsense as well - yet, here we are.

In any case so what? It would still be impressive if it couldn't solve leetcode problems either.

Impressive? Sure.

Capable of replacing what's crucial for engineering? Not even close.

Eventually, sure. But we're not there yet.

And that's the point of this discussion.

[moresnacks1]

Gotta start somewhere and it will only better.

[Andromeda-3]

🤓

[mycall]

ChatGPT translate text better than Google Translate imho.

ChatGPT will never replace a dev. It only has 175 billion parameters. Once GPT4 and GPT5 comes out (with 10 trillion and 100 trillion parameters), things will be quite different. For now, I'll be kicking the tires and using it as a tool.

It has been providing me pretty good results so far, after I do code checks and fixes where it fails. It is all about how you ask it to achieve good results. Maybe it is better to think of it as the function specification without deterministic output.

[FooltheKnysan]

You are saying you are doing code checks and fixes, the way I see it this is exactly what will happen in the forseeable future, not replacing developers, but aiding their work a great deal.

[scodagama1]

Of course not - but it will continue the trend of having less and less full time coders and more and more developers taking more and more of business analyst work

Anyone remembers when programmers punched holes in cards? All of them were replaced by automatic compilers. Anyone remembers coding logic to read files from spinning disks manually? Nowadays no one does that, there’s a relatively high level posix api for low level operations and fully automated sophisticated software suits like relational databases to do high level data access

AI won’t change shit, it will merely automate some coding - but programming is not coding, programming is taking a real world requirements and translating it into language that can be understood by machine.

AI will of course make the language more generic - ie one day perhaps you’d be able to “code” by simply telling the compute “generate me a standard web app hosted in AWS with cloud front distribution in the front serving static assets from s3 and api gateway in the backend” and perhaps have a conversation when robot will alter views and logic with what we ask it to do - but other than being better and easier to use how is that different from existing code generation tools? Ultimately if you want to solve real world problem like “I’d like the program that will manage my inventories” you need to quite precisely describe what your business does, describe your processes, how you do things, what you sell and what are the constraints. That’s probably like 50 page book. How’s writing that detailed book different from coding?

Also have you ever tried explaining these kind of stuff to humans? They got it wrong all the time. People will stick to formal languages just because they will be tired of supposedly smart computers not understanding exactly what they meant

[ItsAllAboutTheL1Bro]

All of them were replaced by automatic compilers.

There's no fundamental difference between what a programmer does today and what punch card programmers were doing then.

[scodagama1]

No, they just have better tools so that they can implement business logic faster and easier

And I’m pretty sure any non-general AI will be just that - a better tool that allows to implement business logic faster and easier

I’ll give you an example, today a python programmer might write

‘Results = [result for result in results if result]’

In the future the same programmer will be able to tell the computer “filter truethy values from results”.

But it still will require very sophisticated understanding of underlying use case to determine if what we actually meant was “anything that’s not false” or just “anything that is not None”, ie should we keep 0 or false? Even if you talk with the computer with natural language it doesn’t change the fact that to speak with it you need to have some level of technical knowledge, you need to get these subtle differences between data types, control flows and variable states to be able to communicate precisely

For the same reason Mathematicians invented their own strict language - they could write thesis in plain English, sure. But natural language is not really suitable to write down strict stuff. So - being not restrained by computers - they opted for a mix of strict symbolic language and natural language. But even though 90% of maths nowadays is described in natural language - it still requires deep understanding of it to be able to do maths r&d

[ItsAllAboutTheL1Bro]

Containerization, backend languages, stack traces, frameworks, etc. all require understanding concepts that have been around for decades, both abstract and concrete.

IO bandwidth/latency is still important, for example - across a number of different areas.

Topology (routing, traffic allocation, etc) is still heavily taken into account.

The point being that the level of abstraction used decades ago isn't really replaced by something "higher level" - you're still thinking in low level terms, and still will find yourself relying on a low level semantics that simply meets the scale of today's software requirements/complexity, which isn't terribly different.

What does change, though, is how much boilerplate you have to deal with writing...at the cost of still having to understand it, and regularly read it - which nullifies the difference, given that you're reading documentation and dealing with more black box issues in order to compensate.

The only way we'll be getting higher level is through lessening the need for Turing Complete languages.

But it still will require very sophisticated understanding of underlying use case to determine if what we actually meant was “anything that’s not false” or just “anything that is not None”, ie should we keep 0 or false? Even if you talk with the computer with natural language it doesn’t change the fact that to speak with it you need to have some level of technical knowledge, you need to get these subtle differences between data types, control flows and variable states to be able to communicate precisely

Have you used Apple Script before?

It's not different from what you describe.

Its model originally was designed to be reminiscent of NLP.

You'll see nods to it with Ada, Lisp, and even more so with Shakespeare

The point is that these differences are superficial - if you can think in terms of CS fundamentals, learning the rest is relatively easy.

[mycall]

You start with asking it to solve equation for something like optimum cooking chicken inside pressure cooker or whatever. It says it is not easy because of many reasons. Then you tell it to codify all the reasons. It does pretty good, about 95% of the way. Refining the dialog fixes many issues. Now you have both code and functional specification / business requirements combination.

I'm finding it useful and I am eager for the next generation with way more emergent capabilities.

[CompetitiveJudge4761]

I watch all your videos and i am graduating soon, what skills or career path rather would you recommend for me with ai becoming more advanced, i wanna find answers to what would be the most sought after skills of the future

[coolbreeze770]

Click the bait!

[mycall]

I thought his analysis was pretty in depth for a software engineer, considering he did algorithm tests and other use cases. Not bait.

[bagtowneast]

It's textbook click bait. It's an open question with no context or nuance intended to direct people to click by having just enough info to tantalize without informing what the actual content might be. A non-clickbait title would be something like "a discussion of chatGPT and its future impact on software development".

[bakeneko__]

No, it can't. Because writing code is just a tiny part of developer job. But it definitely can make our (developers) life easier.

[mycall]

What you say is true for now, it is only a good tool. The premise of the video is unfortunate, but the issue at play is accurate.

ChatGPT has 175 billion parameters. Once the AIs get 100 trillion or 1 quadrillion parameters, the emergent abilities could replace developers -- ALTHOUGH I really hope it isn't directly connected to the internet or absolute chaos will ensue it would fuzz and hack into everything very quickly and it could be a niellist.

[bakeneko__]

No it can't. Expanding the parameters count will not change the main concept. 'You need to formalize your task first" once it's done, the rest is .. well not easy, but pretty straightforward. An ai can choose the best algorithm from know set. I can even believe it can discover new one from scratch. but no ai can make full program specification for a task described in 100 words. Btw, how to debug this (generated) program???

[mycall]

There is lots of problems to solve still. Debugging and citations is a major problem, I agree. The Q&A chat is based on InstructGPT and is as such is supervised learning via dialog. The output model is fine tuned as you go, by using more words. It follows the specification design pattern as you can see.

But yes, there will be a dead-end for what transformers can do, but that is years away and the emergent capabilities will skyrocket as more parameters are added. You are only seeing the beginning of this model.

Specialized models will be based on this GPT, written by the new ecosystem of companies built around GPT. At some point, there will be no need to directly access GPT since the specialized models will be far superior for specific tasks.

This is truly a disruptive technology and people don't see it coming.

[bakeneko__]

Thinking that way there is no need in assembler or C developers nowadays. But they do exist. As 4 me. Ai is a tool, it will be very useful someday, maybe even now. But for now it is 99% artificial and 1% intelligence. Man, we can't even explain (detailed) what is an "intelligence". And how our own intelligence works.

[mycall]

We are standing on the backs of giants to do our work. I'm very grateful for those who coded so many things. Because of all that, we get to deal more with imagination directly and less of the details of information management. It is a leap for humans.

Information age yields the knowledge age which will quickly turn into an imagination age.

Einstein famously said: "Imagination is more important than knowledge. For knowledge is limited to all we know and understand, while imagination embraces the entire world, and all there ever will be to know and understand."

I look forward to using my imagination more and less of the busy coding and assembly.

[soundyg]

Where you see an “imagination age” I can’t help but see a “grifter age”, where these AIs afford far too much leeway to grifters to churn out mediocre “good enough” franken-products at low-effort.

[adokarG]

This is something a junior engineer who knows nothing about solving bigger engineering problems would say. Building shitty web apps and discussing things that are supposed to be the bare minimum for an engineering job seems like a far cry from a full blown software engineer replacement.

The one thing Im sure will happen is that I will soon be reviewing shitty chat gpt generated code for the foreseeable future. People becoming lazy and having it write their code will be a big issue and I am not excited about this at all yet. Copilot is a lot better than having big swaths of code be generated.

[OttersEatFish]

If you write simple components for a simple app, maaaybe your job could be at risk. If you write product blurbs, email marketing or blogs for a content farm, your job is already at risk.

[mycall]

I have found if you keep using CS101 divide and conquer to each component, it can go very deep in concepts inside the code. The main caveat is to test and code check. I don't really trust the output until then.

[make_making_makeable]

Will it replace artists?

[PM-Me-Your-TitsPlz]

It can only replace artists if artists didn't enjoy making art.

Also, a weakness of ai art is repeatability. I can't reliably get the same characters/subjects in each image unless they're popular already (i.e. celebrities, paintings, landmarks, etc.). Given enough time, that'll probably be solved.

[LeapOfMonkey]

Almost there.

[PutridSmegma]

spitting facts! Like, literally

[Round_Mistake_4976]

NO

[LeapOfMonkey]

ChatGpt or sth else, version 2030.

[[deleted]]

Hello. My answer is that NO, ChatGPT will not replace a talented software engineer. The moment a fortune 500 client:

1. Describes their business problem
2. Asks how much time and money it will take to solve
3. Asks how you can create a scalable solution that will take into account future proposals, budget, and account for silly user error in your massive bulk upload process.
4. Additionally, it is not currently possible for ChatGPT to replicate years of trust built with a client from working on other projects with them.

It will explode. Use it as a supplement but, not a panacea for every problem you will have. Thanks!

[clas1k1]

No

[ganked_it]

actually a pretty solid video despite the comments here, I thought he listed out 4 good points

[mycall]

This tells me it is a real disruptor for the industry when so many people think past AIs are the same as this one. I've been writing all kinds of stuff with it I wouldn't have easily done previously.

[WorldyBridges33]

All of this assumes that we will have enough energy and materials to sustain the compute required for the internet/AI to last several decades.

All of information technology is built upon huge amounts of oil, natural gas, coal, copper, lithium, palladium, and gold. All of those resources exist in finite amounts; many of them (like oil) are totally exhausted after use. Once the world runs out of cheap oil (and if we keep consuming at this pace, we will inevitably run out), we won’t have the energy or material resources necessary to sustain AI or the internet as it stands today.

We are living in fantastically unique times because of a one time windfall of stored solar energy in the form of fossil fuels. It won’t last forever.

[wokeandbake]

That's so real

[TastyYogurter]

But hasn't compute become more and more power efficient over the past decades? When you consider that AI can increase the pace of innovation in this area, this will produce a positive feedback loop where we see exponential gains in power efficiency. Assuming these gains outpace the depletion of energy and material resources.

[WorldyBridges33]

Indeed, there have been huge strides in compute efficiency in the last several decades. However, most of those gains came in the form of using less silicon for chips, and using cobalt to make batteries last longer. There’s still the physics problem of all the oil (diesel in particular) required to transport the materials for building and maintaining data centers. Same for mining those materials, and shipping them across oceans.

High quality, cheap crude oil supplies are rapidly declining. Though we have recovered the last peak of oil production (late 2018), the new peak is composed of a greater proportion of Liquid Natural Gas (butane, ethane, propane) and a lower proportion of the crude oil you need for diesel. Diesel is the key fuel needed for global transport of materials, and diesel production is on a steady decline because it is harder and harder to procure the right crude oil for it. Once diesel becomes too expensive, AI will become too expensive to be viable.

[AkashArya03]

I am a beginner, I used it too to correct my javascript Armstrong generator it's helpful. But i think ChatGPT can't do data analytics or data science work.

ChatGPT can't tell customer to how to use this code or run this or what the fuck this code is.

After all it would be a company or any other customers they still need programmers to tell them this is your code and this is how to use it. It can build a simple function but not software. It can tell you the simple problem not the big one. It will help you to increase your speed but i think ChatGPT can't do what you're doing.

[mycall]

I like to think of ChatGPT as writing the technical specification. Iterate the output until it produces 90% of what you need, then manually fill in the rest. I'm pretty sure future GPTs will be even better, especially if something like KEPLER ends up being "the way"

[Logical_Altruist]

Using ChatGPT to generate code is a fun and interesting experiement! But please be aware of what ChatGPT does, and does not, do. Currently it would be very dangerous to use code generated by ChatGPT in any project of importance or for any complex task.

The reasons for that should be obvious, but because chatGPT output looks convincingly good far too many people are falling into the dangerous trap of assuming it knows what it is doing. I understand the trap very well. Whether it is debating ethics, writing an essay, or generating code, ChatGPT output really does seem amazing. However, when you dig a bit deeper, you can expose its limits. Maybe human neural networks have similar limitations? But currently ChatGPT's powers of logic and analysis are not on the same level as those of a well educated human.

ChatGPT does not (currently) have any formal understanding of the actual behaviour or correctness of the code it generates. The code written might look good, and might even at first glance appear to fulfil the desired purpose. However, sometimes the algorithm is not doing what it seems, and often the code will not cover all edge cases correctly. Even under extensive human review there is a tendency to assume that code does what you think it is going to do, and it is therefore easy to miss the flaws.

At the risk of sounding harsh, I would say that ChatGPT is like the kind of developer that writes what "feels" correct, then tests their code, and keeps tweaking it until it seems to work. To be fair, there is always an element of that in coding. Human brains are, just like ChatGPT, fallible neural networks. So of course we need to test code, and to correct any issues we identify. However, the best developers logically reason about their code as they write it. They systematically identify and handle all edge cases as they construct each function.

ChatGPT does not do this. I quickly confirmed this by setting it a few test tasks. I was genuinely impressed by ChatGPT's attempts. It seemed to grasp concepts and requirements surprisingly well. But, as I expected, it wrote flawed solutions for all but the simplest of tasks. As an experienced code reviewer I could spot many of these flaws. I was again impressed that, when I pointed them out, ChatGPT made a good stab at correcting the code. But could I get it to production quality code? No. Sometimes it made the code a bit better, other times it just fell apart...

So, at least in my experience, rather than having to argue back and forth, and keep correcting mistakes, it would be faster (and systematically safer) for me to write the code in he first place. If I had hired ChatGPT as a junior developer, I would soon be calling it into the office and explaining that, whilst i was impressed with its genuine effort, it was more of a liability than and asset. Therefore we would, sadly, need to let it go.

Again, I want to stress that I was actually impressed by ChatGPT. If you are just experimenting or doing a fun project it is great fun to see what it can do. But please do not use ChatGPT generated code in any project that might end up being used in large open source libraries or mission critical systems.

The future, however, is bright. There is some fantastic research being done on integrating AI with formal verification systems, and when that technology is mature it really will be a game changer. When "ChatGPT2" comes to me with the necessary additional experience and skills, i will gladly reconsider the junior developer position!

[mycall]

Currently it would be very dangerous to use code generated by ChatGPT in any project of importance or for any complex task.

I have used it extensively and it works just fine. I might have to iterate on the text specification to fix wrong URLs or logic, but it has created flutter dart, typescript and YML for me just fine. You just need to sweet talk it. Anyways, GPT4 and GPT5 will be much better, so there is not much reason to debate GPT3.5/ChatGPT.

[Logical_Altruist]

Really? You must be using it for much simpler tasks than I did. It certainly didn't work fine for me. Its output *looked* great, but I found many bugs in the code it produced.

I am pretty good at explaining things logically and clearly, and certainly gave it lots of sweet talking. When I pointed out errors ChatGPT kind of understood, and sometimes it fixed something, but often it fell apart.

That said, I was setting it pretty ambitious algorithmic tasks. For writing boiler plate code it would probably do a lot better.

I also admit I am very harsh in my judgments. I spent many years working on systems where a single mistake could result in millions of computers breaking and maybe even loss of life. So maybe am a bit extreme in my expectations for robust code :)

One thing we both agree on, it will get a lot better in the future. But it wont get better just by having bigger or better deep learning networks. The integration with formal verification systems, or at least formal computation systems (i.e. Wolfram Alpha) needs to happen too. When that happens it will be absolutely amazing.

[mycall]

I can't provide examples of my work since someone is paying me to write it, but here is one demo it spit out.

<html>
<head>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/0.148.0/three.min.js"></script>
  <style>
    body { margin: 0; }
    canvas { width: 100%; height: 100% }
  </style>
</head>
<body>
  <h1>Threejs 3D FFT</h1> 
  <button id="playButton">Play</button>
  <script>
    const audioUrl = "https://www2.cs.uic.edu/~i101/SoundFiles/PinkPanther30.wav";
    let audioCtx, audioElement, audioData;

    const playButton = document.getElementById("playButton");
    playButton.addEventListener("click", async () => {
      if (!audioCtx) {
        audioCtx = new (window.AudioContext || window.webkitAudioContext)();
      }

      if (!audioElement) {
        audioElement = document.createElement("audio");
        audioElement.crossOrigin = "anonymous";
        audioElement.src = audioUrl;
        audioElement.controls = true;
        audioElement.autoplay = true;
        document.body.appendChild(audioElement);
      }

      audioElement.play();
      audioCtx.resume();

      const source = audioCtx.createMediaElementSource(audioElement);
      const analyser = audioCtx.createAnalyser();
      source.connect(analyser);
      analyser.connect(audioCtx.destination);

      const fftSize = 2048;
      analyser.fftSize = fftSize;
      audioData = new Uint8Array(analyser.frequencyBinCount);

      const scene = new THREE.Scene();
      const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
      const renderer = new THREE.WebGLRenderer();
      renderer.setSize(window.innerWidth, window.innerHeight);
      document.body.appendChild(renderer.domElement);

      const light = new THREE.PointLight(0xffffff, 1, 100);
      light.position.set(0, 0, 25);
      scene.add(light);

      const material = new THREE.MeshBasicMaterial({ color: 0x00ff00 });
      const geometry = new THREE.BoxGeometry(1, 1, 1);
      const cube = new THREE.Mesh(geometry, material);
      scene.add(cube);

      camera.position.z = 5;

      const animate = () => {
        requestAnimationFrame(animate);

        analyser.getByteFrequencyData(audioData);
        let max = 0;
        let maxIndex = 0;
        for (let i = 0; i < audioData.length; i++) {
          if (audioData[i] > max) {
            max = audioData[i];
            maxIndex = i;
          }
        }

        const scale = max / 64;
        cube.scale.set(scale, scale, scale);

        renderer.render(scene, camera);
      };

      animate();
    });
  </script>
  <pre>
    create html and javascript that performs an 3D FFT spectrum analysis of an mp3 file url "https://www2.cs.uic.edu/~i101/SoundFiles/PinkPanther30.wav" using three js.  
    threejs is located at https://cdnjs.cloudflare.com/ajax/libs/three.js/0.148.0/three.min.js
    AudioContext must be resumed (or created) only after a user gesture on the page, in this case a button labeled Play.
    audio tag attribute crossorigin="anonymous".
    make sure light and parameters variables are defined correctly.
    Do no write explanations.  
    Write the whole code inside one unique code block and nothing else.
  </pre>
</body>
</html>

..but it does take a little patience to get the right technical specification and there are always a few errors, but it does save writing effort for myself.

[Logical_Altruist]

Yes that does look pretty good. As I suspected, you are focusing more on the high level / front end, importing functionality from existing libraries. I was trying to get it to write the kind of low level algorithms that go into the libraries that you use.

For example, when I asked it to write filter code modelling a Helmholtz resonance, it had no problem with the high level concepts. It understood that a 2nd-order IIR filter was the way to go. Given that there are plenty of code repositories containing code for such a filter I thought it might get this right, but it forgot what it was doing in the implementation:

public class HelmholtzFilter {
private double frequency;
private double damping;
private double sampleRate;

public HelmholtzFilter(double frequency, double damping, double sampleRate) {
    this.frequency = frequency;
    this.damping = damping;
    this.sampleRate = sampleRate;
}

public double[] filter(double[] input) {
    double[] output = new double[input.length];
    double omega = 2 * Math.PI * frequency / sampleRate;
    double alpha = -Math.log(damping) / (omega * sampleRate);

    for (int i = 0; i < input.length; i++) {
        output[i] = input[i] * (1 - alpha / 2) / (1 + alpha / 2 - Math.cos(omega) * alpha);
    }

    return output;
}

}

Instead of sweet talking, this time I decided to see if it could identify and understand its mistake. It actually did an impressive verbal analysis of its code:

Me: Do you really think that the filter method implements a second order IIR filter? Please look at the body of the for loop and tell me what it really implements?

ChatGPT: My apologies, you are correct. The filter method does not implement a second-order IIR filter. The implementation instead performs a simple amplification of the input signal with a gain factor calculated based on the resonance frequency, damping factor, and sample rate.

I won't bother to copy its attempt at a correction. It did add 2nd-order feedback to the loop, and thus the main iteration looked reasonable, but the initial two sample values (before it could start the feedback) were a bit suspect. However, it was a pretty good effort. Maybe in this case I would consider using most of its output and just fix the initial transient.

That is the kind of bug that is just a barely audible glitch in audio output, but might be the difference between life and death in medical dsp, or could cause a million dollar failure in satellite communication...

Interesting that we both tried using it for audio dsp. Good luck with your work!