I'm pretty sure there's some hysteresis going on - if we randomly end up in the ambiguous zone on the bluer side, we'll be pressing "blue" every time a small change happens, because it's basically the same color. Until the changes add up so much that we're out of the ambiguous zone on the green side - and now our "border" is far on the green side. But if we started on the other side, entering the ambiguous zone from the green side, it'd take a big cumulative change before we press "blue".

don't get me wrong, it's interesting, but the response here didn't answer the question

If you can make an LLM generate something novel and can prove it wasnt in the training data, call me

For instance I asked GPT to make some game concepts for a more narrative game with an emphasis on locked areas you'd have to get through, and here's a few of its ideas:

1. Masquerade Ball of Eternity: Set in a never-ending palace ball where attendees wear masks that indicate their access levels. To gain entrance to different rooms, players must persuade, charm, or deceive other guests to swap masks or uncover clues about hidden access points.

1. Fantasy Festival: A week-long festival in a magical kingdom where different events, shows, and parties require special passes. To get these passes, players must navigate the gossip mill, undertake tasks for performers, or sneakily forge invitations.

3. Library of Forbidden Knowledge: Every floor of this immense library has knowledge more restricted and coveted than the last. To move up, players must win debates, discover hidden lore, or befriend ancient librarian spirits.

4. Zoo of Mythical Beasts: To access each enclosure, players must understand and empathize with the creatures, learning their stories, likes, and dislikes to gain passage without arousing suspicion.

(Now I can hear you saying: but aha! Every one of those ideas is made up of letters and words found in the training set!)

The fifty move rule[0] is quite simple, just store a number, fits in five bits. But the threefold repetition rule[1] is quite a pickle - it basically means that to know everything about a position you need to know every position that occurred before it.

[0] https://en.wikipedia.org/wiki/Fifty-move_rule [1] https://en.wikipedia.org/wiki/Threefold_repetition

Another straightforward thing missing is the player's turn; this could determine whether the position is a stalemate or not.

But the standard, FEN, doesn't store that either. It's used more in the context of a full game than with individual positions.

FEN doesn't store previous states, but EPD can. It just goes to show how meanings and requirements change depending on context, which is super interesting in and of itself :P

You can’t repeat the last position. But repeating a pattern of part of the board every two turns can force progress to resolution. The entire board never repeats, but it also stops the loop earlier.

> Challenge accepted! Here's your humorous and sincere reply:

did this one just leak part of the prompt?

looking through the profiles of some of these they spam random subreddits with inane comments, often completely misreading the mood of the original post

I am normally not very conspiratorial, but all this is just jumping out at me.

Because the technology has been making big leaps over the past couple of years, the comparisons are now being made not with what used to be before, but with what is being promised. And in that regard, things do fall short.

Basically the hype builders hyped things up so much they started hurting the hype.

And was a photographer long ago, double luck huh.

(I’m also Not an illustrator)

I've created music and art in a visual medium and there's a lot of post hoc justification that your brain likes to present

AI isn't drawing like a human artist does. It's a completely distinct process from someone putting marks on a page. The caveats, or turds as the author of the original article put them, are pretty difficult to fix without having actual training and skills in art, and acquiring those skills is a lot harder than learning to take photos.

-- Roy Amara

It's a very complicated subject with several meta-conversations, and things being the way they are, a lot of people need to project arguments onto "They"

Here, we see a misinterpretation: its not "it's going to replace profession wholesale", it's a simple causal chain "hey you do 30% more work with GPT" => well then you need ~30% less workers => affect employment.

And we can run out a centithread of chastising any number of groups under the sun of maximalist claims, ex. from here, directly spin into "well _some_ people argue for complete replacement of artists", spin that into AGI doomers, etc.

I see a potential risk here.

This is HN, so let's consider programmers in isolation for a moment. Today, I can issue the following prompt to ChatGPT and get a solution that works:

> Using Python, generate an example unit test that uses monkey patching.

That gives me a runnable, valid example test. I can then ask it to refactor it to use pytest instead of unittest:

> regenerate the above code sample using pytest instead of unittest.

Here's the resultant code:

    # A simple class that we want to test
    class Calculator:
        def add(self, a, b):
            return a + b
    
    
    # Monkey patching the add method to subtract instead
    def mock_add(self, a, b):
        return a - b
    
    
    # Test the monkey patched method
    def test_add_with_monkey_patching():
        # Create an instance of the Calculator class
        calc = Calculator()
    
        # Monkey patch the add method of the Calculator instance
        calc.add = mock_add.__get__(calc, Calculator)
    
        # Test the monkey patched method
        result = calc.add(5, 3)
    
        # Assert that the result is what we expect
        assert result == 2

Here's where I think there is a potential major issue: As someone who is currently a "Senior Staff Software Engineer" and has been doing this sort of work for two decades now, if you had given me the same prompt my first response would have been "use monkey patching to do what?". ChatGPT doesn't do that. Instead, it gives you a response that best fits the question. It includes a half dozen paragraphs explaining the code, what it does, and what monkey patching is, sure... but it doesn't even touch on why you'd want to use monkey patching, when it is or is not the best approach, or any alternatives. In short, ChatGPT lacks the intuition that a human programmer will develop over the course of a career.

It's getting better. A few months ago I could have asked ChatGPT the same question and probably 30% of the time gotten a result that would even run. In the past couple of months I don't think I've run into that at all.

The "intuition" thing is a big deal, though. ChatGPT is a great tool in the hands of a competent engineer who has the experience to examine the output with a critical eye. Today, I could see it replacing a junior engineer in a professional setting. We should not use it in that way.

If we do, in a few years we'll get to the point where the current generation of senior engineers are retiring. If we've replaced the majority of our junior engineers with AI, we'll be left without people who can use the AI-generated results effectively.

There has to be a way to balance the savings represented by these tools (in terms of both time and money) with the fact that the people who are able to most effectively use it today only got to that point because they've spent much of their adult lives developing the exact skillset that we're proposing to replace with them.

I mean, you might not look at job postings for Jr. Engineers anymore, but they all ask for someone who can lead and mentor teammates less senior than they are so it seems like there won’t be many replacements for senior engineers retiring in the next decade regardless of ai’s existence.

Have you tried telling it who it is? You're coming at it with context about how it should act without telling it - it can role play a lot of things. I spoke to a teacher dealing with kids doing their homework too well with it, and showed you can just say "write X as a student with middling English" and get realistic mistakes.

> as if that actually stops this thing from hallucinating bullshit all the time.

This has nothing to do with hallucinations though. It's about giving something a poorly specified problem and then complaining that it gives a valid answer but doesn't act like a particular persona when that persona was not explained. This is a very general problem with a general approach to fixing it. Want it to challenge you on what you're asking it to do? Tell it that.

That raises the question of why they used it ineffectively in the first place then. They asked it to do something, it did, but they say it misses the point that a senior engineer would spot. My point is that if you want to judge how well it operates in replacing someone you have to actually specify who it's supposed to be imitating. It's not idle speculation, as I said I did this and it worked. Asking it for an example of monkeypatching gave back a proper example, along with a warning about maintainability.

Telling it I was a junior engineer and wanted to use monkeypatching did the same thing. Asking a followup of why I should be so careful with it and what I could do instead it gives explanations about several problems and then a few other approaches. Telling it simply to be a senior and I'm a junior, and that it should come up with followup questions for me it not only explains those problems but gives me the kind of followups a junior should ask but may not know to. Exactly the kind of intuitions about what's going on that are said to be missed here.

So I think the example used is significantly weaker than it appears, and the argument hinges on what GPT4 is lacking.

Now, a very solid response to the problem posed is that if it can approximate a more senior role for discussions it can make junior engineers more effective and teach them those skills.

> I told it that it was a senior engineer and I was a random client and asked the same thing.

I’m aware that ChatGPT is capable of performing the task I chose. I agree that it’s a relatively weak example, especially if it was my goal to show that AI can’t do this.

That’s not really what I was trying to show, though. My point is that you knew two things that many/most people probably wouldn’t:

1) That crafting your prompts to get the LLM to adopt a “persona” impacts the results significantly

2) That monkey patching has downsides, and that understanding when it is appropriate is important

I strongly suspect that you knew both of those things because you are a senior engineer yourself. My point is that some level of domain knowledge is necessary to get good results from it; my fear is that one day in the not too distant future, far fewer people will be around with that knowledge, because we’ve slowed the “senior engineer pipeline” down to a trickle through the use of these tools.

Here's a relevant paragraph

> That said, it's crucial to understand that monkeypatching can make your tests harder to understand and maintain if used excessively or improperly. When you monkeypatch, you're essentially altering the normal behavior of your code. This can lead to situations where tests pass because of the specific setup in the test and not because the actual code is correct, making it less effective at catching real bugs.

More than that, I could instead tell it at the start to tell me the questions I should ask as followups, here's the list when I told it I think I need to use monkeypatching:

1. When is it appropriate to use monkeypatching and when should I avoid it?

2. What are some common pitfalls or mistakes to avoid when using monkeypatching?

3. Can you give me more examples of how to properly use monkeypatching?

4. Are there any other techniques or tools for mocking or stubbing that I should consider?

I could then just say "answer those". No prompting about assuming downsides or problems.

I agree on point one but it's a very easy lesson to learn - try telling it that it's a pirate. It's also not actually required because someone like me can create the persona prompting and then everyone else can just use it. I'm not subtly crafting a weird prompt, it's just telling it who to be for the most part.

> my fear is that one day in the not too distant future, far fewer people will be around with that knowledge, because we’ve slowed the “senior engineer pipeline” down to a trickle through the use of these tools.

On the other side, what we have here is potentially an infinitely patient, always available mentor. You don't have to crash through mistakes on your own to learn, though some lessons are learned harder because of that.

The name choice is interesting. If one of the first things in your FAQ is "the name probably made you think this is thing X. it's not", then maybe there was a flaw in your naming process.

API started as WebVR, was renamed to WebXR since now accommodates more than VR (AR, MR…)

I worked with Vlad at Mozilla in the early WebVR days (I co-design while at Mozilla and now maintain A-Frame)

"As such it may seem like WebXR and OpenXR have a relationship like WebGL and OpenGL, where the web API is a near 1:1 mapping of the native API. This is not the case with WebXR and OpenXR, as they are distinct APIs being developed by different standards bodies."

from https://github.com/immersive-web/webxr/blob/master/explainer...

Source: I was there for the discussions.

The same settings but with min speed got caught at the z, creating what looked like repeating waves then a few letters that I couldn't place from the phrase.

Also amusing are the loops that get the tops cropped even though other letters extend higher.

as usual, the errors are at least as interesting as the successes on new tech!

Should I assume humans will soon achieve immortality and stop breeding (or just go extinct) just because it makes me less of an outlier? Cause that seems to lead to the exact opposite conclusions, just by putting the delineation point at an individual rather than a civilization.

"Furthermore, we should believe that loud aliens exist, as that’s our most robust explanation for why humans have appeared so early in the history of the universe." The most robust explanation for humans appearing so early is that yeah, it seems we did appear early, someone had to - since it doesn't assume an entire model of intergalactic civilizations.