ChatGPT is bullshit

Some reality check reading for the starry-eyed
"Bullshit" in the article (and the thread title) is used in academic Frankfurtian sense.
https://link.springer.com/article/10.1007/s10676-024-09775-5

I know you guys are fascinated by bots seemingly "understanding" you, but can we finally see an example of "ai" writing a solution to a specific unique problem that includes more than 100 loc and more than 1 module? I mean the stuff people who will supposedly lose jobs to "ai" do on a daily basis. 1000s of examples of conway's game of life and bubblesort are starting to lose their wow factor.

And for umpteenth time: programming is not code typing. It's systems design. If your job is to just type code, I'm all for copypasting machines automating your job away. That job was draining your soul anyway.

As for zuckbot, its "predictions" are worth diddly-squat. Remember when zuckerverse was to change the way we interact online, two or so years ago? "Any time now". "It's just around the corner". Yeah, just like self driving and flying cars. And rainbow farting unicorns.

I read it on reddit that if I don't "adapt and embrace ai", I'll soon fall behind and die off. Since I don't want that to happen, I said, heck, don't be a boomer, let the good ai help you. Here's what happened:

. . .

xyz: I need a GDScript class or a function that implements marching squares using a compute shader. The input should be a 2d array of samples and the output should be a mesh resource.

Copilot: Sure, I can help you with that! Here's a basic implementation of the Marching Squares algorithm using GDScript and a compute shader in Godot. This example assumes you have a basic understanding of Godot and GDScript.

Copilot: First, create a new shader file for the compute shader:

// marching_squares.compute
shader_type compute;

layout(local_size_x = 1, local_size_y = 1) in;

uniform sampler2D samples;
uniform int width;
uniform int height;
buffer MeshBuffer {
    vec4 vertices[];
};

void main() {
    ivec2 pos = ivec2(gl_GlobalInvocationID.xy);
    if (pos.x >= width - 1 || pos.y >= height - 1) return;

    float tl = texelFetch(samples, pos, 0).r;
    float tr = texelFetch(samples, pos + ivec2(1, 0), 0).r;
    float bl = texelFetch(samples, pos + ivec2(0, 1), 0).r;
    float br = texelFetch(samples, pos + ivec2(1, 1), 0).r;

    int case_index = int(tl > 0.5) | (int(tr > 0.5) << 1) | (int(bl > 0.5) << 2) | (int(br > 0.5) << 3);

    // Add vertices based on the case_index
    // This is a simplified example, you need to add the actual vertices based on the case_index
    if (case_index == 1) {
        vertices[pos.x + pos.y * width] = vec4(pos.x, pos.y, 0.0, 1.0);
    }
}

Copilot: Next, create a GDScript class to handle the compute shader and generate the mesh:

# MarchingSquares.gd
extends Node

var compute_shader : Shader = preload("res://marching_squares.compute")
var compute_material : ShaderMaterial
var mesh : ArrayMesh

func _ready():
    compute_material = ShaderMaterial.new()
    compute_material.shader = compute_shader

    var width = 100
    var height = 100
    var samples = Image.new()
    samples.create(width, height, false, Image.FORMAT_RF)
    samples.lock()

    # Fill the samples with your data
    for x in range(width):
        for y in range(height):
            samples.set_pixel(x, y, Color(randf(), 0, 0))

    samples.unlock()

    var image_texture = ImageTexture.new()
    image_texture.create_from_image(samples)

    compute_material.set_shader_param("samples", image_texture)
    compute_material.set_shader_param("width", width)
    compute_material.set_shader_param("height", height)

    var buffer = MeshDataTool.new()
    buffer.create_from_surface(mesh, 0)

    var storage_buffer = StorageBuffer.new()
    storage_buffer.create(buffer.get_vertex_count() * 4 * 4, StorageBuffer.STORAGE_BUFFER)
    compute_material.set_shader_param("MeshBuffer", storage_buffer)

    var compute = Compute.new()
    compute.set_shader(compute_shader)
    compute.dispatch(width, height, 1)

    # Create the mesh from the buffer
    mesh = ArrayMesh.new()
    var arrays = []
    arrays.resize(ArrayMesh.ARRAY_MAX)
    arrays[ArrayMesh.ARRAY_VERTEX] = buffer.get_vertices()
    mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays)

    var mesh_instance = MeshInstance.new()
    mesh_instance.mesh = mesh
    add_child(mesh_instance)

Copilot: This is a basic example to get you started. You will need to expand the case_index handling in the compute shader to generate the correct vertices for each case. Additionally, you may need to adjust the buffer handling and mesh creation based on your specific requirements.

Copilot: Feel free to ask if you have any questions or need further assistance!

Do I need to tell you how ridiculously funny this is on so many levels?

So what do I do next, fellow prompters? Keep trying? Enroll in a professional prompting course? Or just wait until this time next year?

DJMaesen It's basically useless for any serious production, be it code or art. It's an educational toy for kids at the best. Well, maybe when integrated into a large code base it can serve as a pretty good auto complete.
There are other fields where it can automate pattern recognition to a large degree, and there it can be pretty useful. However pattern recognition is not what the coding or art are about.

kuligs2 How is this useful in any way? This is again an equivalent of writing a bubblesort, with some stupid gui gimmickry on top of it. Let's see how it would deal with an actual problem that is not in the textbook boilerplate domain. Oh wait, the dude in the video tried and it failed and the video abruptly ended with an obligatory "it's not there yet, but imagine..."

It's just more bullshit and make believe.

Natural language is one of the worst conceivable human/computer interfaces, once you need to go beyond trivial parametrization. Try to model an original character this way and let us know how it went.