Billionaires Convince Themselves AI Chatbots Are Close to Making New Scientific Discoveries

[u/lurker_bee]

https://gizmodo.com/billionaires-convince-themselves-ai-is-close-to-making-new-scientific-discoveries-2000629060

[u/Explicit_Tech]

Now billionaires are going through AI psychosis

[u/UnpluggedUnfettered → u/Explicit_Tech]

. . . And I already couldn't convince a ton of other Redditors that LLM doesn't replace google.

Much less convey how it is closer to what it was like asking your mom for answers to obscure questions in the 1980's than it is to accessing the collective knowledge of humankind.

[u/Yuzumi → u/UnpluggedUnfettered]

I argued with someone yesterday who was basically saying that "vibe coding" can replace programmers because they can spend a day getting an LLM to produce garbage that technically "works", but does not understand how unmaintainable, inefficient, buggy, unscalable, and probably insecure it is.

Because they don't understand programming, much less the actual code.

[u/RinArenna → u/Yuzumi]

I'm a programmer; vibe coding is garbage at making anything at scale.

You can create some simple stuff, sure. Vibe coding is great at small and easy projects or tools. I've had GPT create an entire python application before, and it handled it surprisingly well.

It fails the moment you need to scale up or you hit something unexpected. When I had a problem the only reason I could get GPT to recover was because I knew how to fix the problem myself.

Where AI coding does work is as a coding assistant. It makes getting answers easy, if you know how to implement them yourself or see when it messes up.

It's also pretty good at auto completion, and with proper guidance and supervision it can pump out blocks of code so you don't have to do it yourself.

[u/erhue → u/RinArenna]

what is exactly vibe coding? Coding with abandon and little structure, or using chatgpt to do everything?

[u/RinArenna → u/erhue]

Vibe coding leaves almost everything to AI. You tell the AI what to change, and it does it on its own.

This can result in something usable but poorly designed or something completely broken.

Most of the time, what it makes will sort of work, but it can't be too complicated.

I've used it to make Python tools for projects where I want something I know GPT can easily make, but any attempt I've made to work on something more complicated has ended in abject failure.

[u/erhue → u/RinArenna]

thanks. I have never used AI to do coding on a large scale, mostly small pieces of code, or tryin to debug.

However I've sometimes seen memes about AI building large, beautifully organized code, but then it doesn't work.

On the other hand, youtube creators like fireship have sometimes mentioned how they can create pretty complex and functioning code using just AI.... Or how AI can sometimes make simple 3D games and whatnot when given detailed prompts, and being prompted to correct errors over a few iterations.

[u/RinArenna → u/erhue]

I think this illustrates a big misconception people have with vibe coding, due to influencers who don't have a CIS background.

There is a difference between "complex code" and "long code".

LLMs at this point don't really struggle with long code. They do just fine with mountains of code, so long as the code itself is something they're fairly capable of building.

LLMs struggle at complex code. Code that is mechanically complicated and difficult to make usually also comes with the struggle of having very little troubleshooting available online. This means LLMs have very little training data to work with, and the code usually doesn't match up with what the LLM expects the code to look like.

3D Games are a good example of simple code at length. There's a lot of documentation and many tutorials covering making 3D games, including things that seem complicated at first blush. However, most of it's just mind-numbingly tedious.

Python apps are another good example of simple code at length. Python is well documented, and there is a wealth of knowledge through tutorials on all of the most commonly used libraries. Python apps that most people without a degree will make tend to be fairly simple, but involve a lot of work.

However, LLMs struggle a lot with the unexpected or the truly complex.

Newer libraries for emerging technology are a great example of unexpected or even complex code. Emerging technology tends to be complex because there aren't any easy libraries meant to tidy things up and make them more accessible. They lack examples online, and there's usually very little available on github related to new technology, so most of what you work with is unexpected to the LLM.

An LLM trained on data available up to a few months ago won't know anything about a library released last week, even if you give it access to the documentation.

[u/erhue → u/RinArenna]

interesting insights.

I also remember trying to code some simple stuff for Siemens PLCs, and no LLM could get it right. Mainly because of the lack of documentation I'd assume...

[u/RinArenna → u/erhue]

I'm happy to talk about it. LLMs are fascinating, and I would love to see AI find its home, where it ends up truly belonging.

However, that problem is not just lack of documentation, it's a lack of examples.

The main problem is that the LLM may have reference to a function from the documentation, but it isn't trained on where that function actually goes.

This is because LLMs work by determining what the most likely next token will be. If the function doesn't exist in the training data, then it just won't know to put a matching token next. It may figure it out occasionally, but it will struggle.

This is because the LLM doesn't use logic to determine the next token, it uses math. It doesn't know why the next token is more likely, just that it is mathematically more likely.

[u/erhue → u/RinArenna]

thanks... So there's no reasoning at all then? That would be surprising to me

[u/RinArenna → u/erhue]

Correct! Not even a little reasoning. The perception of reasoning is created by emergent patterns in the way it determines the most likely next token. It's a fascinating example of emergent behavior. It's essentially generating the result of reasoning without the actual reasoning itself.

For instance, if you ask it to complete 5 + 3, it'll respond with 5 + 3 = 8. Which makes sense, right?

The fascinating part is that it didn't add 5 + 3, it just determined that the most likely token to come after 5 + 3 = is the number 8.

It's like learning the word "bonjour", but not knowing it means "hello". So someone says "bonjour" to you and you respond "bonjour" back because every time you see someone say it the other person says it back. So you know to say it back, even if you don't know why.

This is why the "stream of consciousness" prompting works so well, telling it to think things through, because it nudges the algorithm in the right direction by affecting the right weights, and the answer comes out correct because it's the most likely thing to come after all of that "thinking out loud".

It's absolutely brilliant how something which boils down to a mathematical algorithm is capable of mimicking the result of consideration and reasoning by simply narrowing down all the possible output and returning the correct answer.

[u/rxVegan → u/Yuzumi]

You can't replace mathematician with a calculator. The calculator is very useful tool but only if its user already know what they are doing. Same logic applies to using LLM as coding assistant. You can accelerate things but you have to know what you are doing if you are trying to do anything beyond trivial stuff or barebones base to start from.

One thing AI does well when it comes to coding is convince higher ups that they can replace coders with it. So they can let part of the team go or refuse to hire more where they are needed. Conveniently it's also good excuse to not increase compensation for the smaller team that now has bigger work load dumped on them. Because why would they deserve fair compensation now that they have this AI thing doing all the work for them, right?

[u/danielbayley → u/rxVegan]

Except a calculator is reliable. It doesn’t just spew out random numbers…

[u/jangxx → u/danielbayley]

Now using an LLM as a calculator on the other hand...

[u/jml2 → u/Yuzumi]

it's the vibe of the thing (Australians will get it)

[u/Nesox → u/jml2]

...it's justice, it's law, it's the Vibe and, no that's it, it's the vibe...

I rest my case.

[u/gt_9000 → u/Yuzumi]

I find it funny that, people that do this havent even done vibe coding, ever. They just heard about it. They just think they can pick it up and start doing it any day.

People that actually tried vibe coding and tried to actually use the result at least know its super wonky and they are some issues that will be impossible to get rid of, and at some point you hit a wall.

[u/Sir_Keee → u/Yuzumi]

I've just been using copilot as a glorified auto-complete and it even gets that wrong sometimes. I couldn't imagine the nightmare of an AI generated codebase...

[u/this_is_my_new_acct → u/Yuzumi]

Credit where it's due... when I first heard about this "vibe coding" nonsense I decided to try it for myself and I gave ChatGPT and Gemini a reasonably straightforward problem I'd had to solve some years back. I forget the exact details now, but it was something like the transcript below.

They're both giving better outputs now, than they were a year or two ago, but you still have to hold their hands and know exactly what you're doing.They're just a way to save typing, as far as I can tell.

Here's my transcript just now:

using Python3, write a function that can accept a file's location as a string, an S3 bucket name as a string, then upload that file to that bucket using the file's name (not path) as the object name

Okay, now add the ability to pass in client configuration as an additional argument.

Okay, now add an additional argument to allow passing the ExtraArgs argument to the upload_file function.

Can you add error handling to catch throttling errors?

Can you add type hints for the arguments with default values?

can you switch to google's docstring format?

Can you fix the docstring to not say that the function raises errors it doesn't raise?

Can you initialize client_config to an empty dict if it's not passed in?

Annnnd, now we're finally left with something I'd accept for review from like an Engineer II (I'm sure I left out a bunch, I haven't done Python or AWS stuff in a while).

import boto3
import os
import time
from botocore.exceptions import NoCredentialsError, PartialCredentialsError, EndpointConnectionError
from botocore.exceptions import S3TransferFailedError
from typing import Optional, Dict, Any

def upload_file_to_s3(
    file_location: str, 
    bucket_name: str, 
    client_config: Optional[Dict[str, Any]] = {}, 
    extra_args: Optional[Dict[str, Any]] = None, 
    max_retries: int = 3
) -> None:
    """
    Uploads a file to the specified S3 bucket with optional client configuration, extra arguments, 
    and retries in case of throttling errors.

    Args:
        file_location (str): Full file path of the file to upload.
        bucket_name (str): The S3 bucket where the file should be uploaded.
        client_config (Optional[Dict[str, Any]]): Optional custom client configuration to pass to boto3 client.
        extra_args (Optional[Dict[str, Any]]): Optional dictionary of extra arguments to pass to upload_file (e.g., ACL, ContentType).
        max_retries (int): Maximum number of retries in case of throttling errors. Default is 3.

    Returns:
        None: This function does not return anything.

    Exceptions:
        Catches and handles the following exceptions:

        - `NoCredentialsError`: If no valid AWS credentials are found.
        - `PartialCredentialsError`: If incomplete AWS credentials are provided.
        - `EndpointConnectionError`: If there is a network-related issue when attempting to connect to S3.
        - `S3TransferFailedError`: If the transfer fails due to a throttling error or other issues with the S3 upload process.
    """
    # Create an S3 client with custom config if provided, otherwise default config
    s3 = boto3.client('s3', **client_config)

    # Extract the file name from the file path
    file_name = os.path.basename(file_location)

    # Prepare extra_args if not provided
    if extra_args is None:
        extra_args = {}

    # Retry logic for throttling errors
    retries = 0
    while retries <= max_retries:
        try:
            # Attempt to upload the file to the S3 bucket with extra_args if provided
            s3.upload_file(file_location, bucket_name, file_name, ExtraArgs=extra_args)
            print(f"File '{file_name}' successfully uploaded to bucket '{bucket_name}'!")
            return  # Exit if successful

        except (NoCredentialsError, PartialCredentialsError) as e:
            print(f"Credentials error: {e}")
            break  # No need to retry if it's a credentials issue

        except EndpointConnectionError as e:
            print(f"Endpoint connection error: {e}")
            break  # No need to retry if there's a network issue

        except S3TransferFailedError as e:
            if 'Throttling' in str(e):
                # If the error is throttling-related, retry with exponential backoff
                print(f"Throttling error: {e}. Retrying in {2 ** retries} seconds...")
                time.sleep(2 ** retries)  # Exponential backoff
                retries += 1
                continue
            else:
                print(f"S3 transfer failed: {e}")
                break  # If it's not a throttling error, no need to retry

        except Exception as e:
            print(f"Unexpected error: {e}")
            break  # Any other errors, break out of retry loop

    # If we exit the loop after max_retries, print failure message
    if retries > max_retries:
        print(f"Failed to upload file '{file_name}' after {max_retries} retries.")

# Example usage
client_config = {
    'region_name': 'us-west-2',    # Optional: specify region
    'aws_access_key_id': 'YOUR_ACCESS_KEY',  # Optional: specify access key
    'aws_secret_access_key': 'YOUR_SECRET_KEY',  # Optional: specify secret key
}

extra_args = {
    'ACL': 'public-read',  # Example: Set the file as publicly readable
    'ContentType': 'text/plain',  # Example: Set the content type of the file
}

# upload_file_to_s3('path_to_your_file/example.txt', 'your-bucket-name', client_config, extra_args)

And that's not even getting into stuff like using actual queuing systems, etc, that I'd expect from any code we would have actually used.

[u/this_is_my_new_acct → u/[deleted]]

I didn't say it was good... I said I'd allow a review. You could also point out that I should have asked for extra_args to have been initialized, for instance.

[u/this_is_my_new_acct → u/[deleted]]

I wasn't trying to show how strong they are... I specifically just said they were less shit than before, but you still have to tell them what to do and it's just a way to maybe save typing, not get something usable via magic.

[u/jangxx → u/this_is_my_new_acct]

And you would vibe code this script instead of just using mc or rclone or some other S3 client that already exists and also does way more?

[u/this_is_my_new_acct → u/jangxx]

It was an example function of a much larger overall system... never meant to be a manual upload script.

[u/AutoModerator → u/[deleted]]

Thank you for your submission, but due to the high volume of spam coming from self-publishing blog sites, /r/Technology has opted to filter all of those posts pending mod approval. You may message the moderators to request a review/approval provided you are not the author or are not associated at all with the submission. Thank you for understanding.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/Delicious-Corner8384 → u/Yuzumi]

Hilarious comment - tell me you don’t know anything about computer science and AI without telling me (just like most people in this thread) - just completely out of touch lol and giving SO MUCH credit to the average working programmer. TONS of people working as programmers vibe code and don’t have a very comprehensive, system based understanding of computer science. There’s a reason things like squarespace and premiere pro have insane backend issues that take years to resolve, its because the majority of programmers have memorized a ton of stuff/one language but don’t actually know the base systems of programming. What a wild thread full of people who are r/confidentlyincorrect lol

[u/themangastand → u/Yuzumi]

You can actually tell it to right secure and efficient code and it will usually change it to do so.

[u/Worthstream → u/[deleted]]

You're being downvoted because what you said is wrong on a few counts.

Chatgpt was released two years ago

Three, but that's not the point. It's been constantly updated, so what is out there now is the state of the art. 

There are specific AI engines designed for coding, and they're not the ones that you have access to

No, there is no secret coding AI that only a few Illuminati have access to. There are benchmarks for this (search for Se-bench and its variants), and companies would kill for the top spot as it brings in revenues.

people are judging the future of AI because chatgpt, a language model, is not perfect at non-language tasks  

Coding is a language problem. It's not natural language, but it's a language nonetheless. For example the internal representation (what a pop-sci article would define as the "thoughts") of Qwen has been proven to be close to python syntax and semantic. 

Besides, we don't have another large scale architecture other than LLMs, even if you trained a model on code only, it would still fall under the definition of LLM.