Latest / DevQuestions with Tim Corey / 285. AI is not a Source of Truth

Transcript

285. AI is not a Source of Truth · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: Objectively, we know AI isn't always correct.
• 0:03
  SPEAKER_01: Unfortunately, it's very confident, even when it's wrong.
• 0:08
  SPEAKER_01: And this, more than anything, represents the danger of AI.
• 0:13
  SPEAKER_01: It also shows us why AI will not replace software developers.
• 0:18
  SPEAKER_01: The problem is that the better AI gets, the more dangerous it will actually be.
• 0:24
  SPEAKER_01: Let's talk about it in today's episode of Dev Questions.
• 0:36
  SPEAKER_00: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:39
  SPEAKER_01: Software development is more than just writing code.
• 0:42
  SPEAKER_01: So let's talk about the rest of it.
• 0:44
  SPEAKER_01: Specifically, let's talk about why AI cannot be a source of truth.
• 0:50
  SPEAKER_01: Societally, we are in a really dangerous place.
• 0:54
  SPEAKER_01: More and more people are turning to AI as a source of truth.
• 0:59
  SPEAKER_01: If you're on Twitter and you see someone making a claim, you'll often see dozens of replies underneath asking Grok if that statement is true.
• 1:08
  SPEAKER_01: ChatGPT has overtaken Google as the first place people turn to get information.
• 1:15
  SPEAKER_01: In the developer realm, Stack Overflow visits have crashed in favor of various LLMs.
• 1:21
  SPEAKER_01: The problem is that we're making more and more decisions based upon the word of an AI.
• 1:28
  SPEAKER_01: A few months ago, I created a course called Navigating AI, where I teach you what AI actually is, how it actually works, and why it hallucinates.
• 1:37
  SPEAKER_01: We also cover how to work effectively with AI and how to not be replaced by AI.
• 1:42
  SPEAKER_01: Now, I'm not going to recap the entire course here, but I want to focus on one bit that we cover in the course in more detail.
• 1:50
  SPEAKER_01: So when AI responds to you, it is guessing based upon patterns it has seen before.
• 1:57
  SPEAKER_01: It's not sharing something it has learned.
• 1:59
  SPEAKER_01: It is not creating something new.
• 2:02
  SPEAKER_01: It's guessing, word by word, what you want to hear.
• 2:06
  SPEAKER_01: Each token, which a token represents a word or a part of a word, each token that the AI spits out is actually fed back into AI in order to generate the next token.
• 2:19
  SPEAKER_01: So it's learning from itself, learning from its own answer to make sure that answer is coherent.
• 2:26
  SPEAKER_01: So that represents an informed guess.
• 2:29
  SPEAKER_01: But then how that guess is made is also important.
• 2:33
  SPEAKER_01: The operator of the AI has to make a decision on how creative it wants the AI to be.
• 2:39
  SPEAKER_01: Not creative enough, and the AI will respond the same way every time you give it the same prompt.
• 2:44
  SPEAKER_01: That's no fun.
• 2:46
  SPEAKER_01: Too creative, and it will return bad data.
• 2:49
  SPEAKER_01: In my course on embedding an offline AI into a C application, we had to play around with the temperature, which is one of the ways you identify how to make the AI more or less creative in order to get different data without getting as much junk data.
• 3:06
  SPEAKER_01: Once you truly understand this process, it will change how you look at the results coming out of an AI.
• 3:12
  SPEAKER_01: But let's look at it from another angle.
• 3:14
  SPEAKER_01: AIs create really good output most of the time.
• 3:18
  SPEAKER_01: When you ask an AI how to do something, that information comes back in a customized to you way that's almost always something that you can follow.
• 3:28
  SPEAKER_01: When Grok evaluates something, it almost always gives a coherent, correct answer, even if the ask didn't like the answer.
• 3:36
  SPEAKER_01: But that's what makes these answers so dangerous.
• 3:39
  SPEAKER_01: Let me give you an example.
• 3:41
  SPEAKER_01: Let's pretend I'm an AI.
• 3:43
  SPEAKER_01: You asked me if sodium was okay for your diet.
• 3:47
  SPEAKER_01: And I say yes, in a healthy amount, since sodium is essential for life.
• 3:52
  SPEAKER_01: And then I tell you about the chemical symbol for sodium was Na.
• 3:55
  SPEAKER_01: And then I recommend that you use Na or sodium in moderation in the food that you prepare.
• 4:01
  SPEAKER_01: That statement is mostly correct.
• 4:04
  SPEAKER_01: But if you follow it, you could be seriously injured or even die.
• 4:09
  SPEAKER_01: You see, sodium is the actual chemical we have in our bodies and other places, but typically we don't get it from, well, we never get it, just from the pure element sodium, because sodium reacts violently with water.
• 4:26
  SPEAKER_01: Typically we get it from NaCl or table salt or from other foods that have Na as part of their makeup.
• 4:35
  SPEAKER_01: So technically, yes, we have Na or sodium in our diet, but we never use pure sodium when cooking or when creating things because of its violent nature and the fact that that's not how we need to consume it.
• 4:51
  SPEAKER_01: So the answer is practically correct.
• 4:55
  SPEAKER_01: It's practical, it's 99% correct, and yet we could die if we follow it.
• 5:02
  SPEAKER_01: That's the danger of mostly correct information.
• 5:07
  SPEAKER_01: You see, it's not that the information is, well, it just got a little mistake.
• 5:12
  SPEAKER_01: No, no, no.
• 5:12
  SPEAKER_01: That's a serious issue.
• 5:14
  SPEAKER_01: It's not, oh, we probably we said, you know, 20 teaspoons of tape of table salt instead of 20 tablespoons of table.
• 5:23
  SPEAKER_01: That's a mistake, that's a bug.
• 5:25
  SPEAKER_01: But when you're talking about life or death, when you're talking about major issues, that's more than just, oh, it's mostly correct.
• 5:33
  SPEAKER_01: As software developers, allowing AI to build software for us based upon our specification is similarly dangerous.
• 5:41
  SPEAKER_01: The worst thing that can happen is that it works.
• 5:45
  SPEAKER_01: So this is something that I came across.
• 5:48
  SPEAKER_01: Recently, I saw an application that was built as a web application that worked.
• 5:53
  SPEAKER_01: It was a web application that had authentication, so you can't get to it unless you have the proper credentials.
• 6:00
  SPEAKER_01: Once you got in, it was able to access some data from various sources, collate it, and allow new data to be created or modified.
• 6:08
  SPEAKER_01: So it worked.
• 6:10
  SPEAKER_01: It worked correctly.
• 6:11
  SPEAKER_01: It did the task it was asked to do.
• 6:14
  SPEAKER_01: It accomplished the goal.
• 6:16
  SPEAKER_01: And so it seemed like it was a good application.
• 6:20
  SPEAKER_01: It was secure, it was protected, all the rest.
• 6:22
  SPEAKER_01: But the reality was that it had exposed multiple API keys.
• 6:27
  SPEAKER_01: It also had hard-coded uh credentials in the code.
• 6:33
  SPEAKER_01: There's other problems with it as well from a performance aspect as well as security.
• 6:39
  SPEAKER_01: You see, it worked and it did the job, it met the specification, and it looked correct.
• 6:47
  SPEAKER_01: And that's the most dangerous place to be.
• 6:50
  SPEAKER_01: Because when it looks correct, then you don't replace it, right?
• 6:54
  SPEAKER_01: You don't fix it.
• 6:56
  SPEAKER_01: You think, well, it's it's correct because it did the job and it's it's working.
• 7:02
  SPEAKER_01: But that's a problem.
• 7:03
  SPEAKER_01: So the common pushback I get on this whole AI is mostly correct and that's dangerous, is that humans aren't 100% correct either.
• 7:12
  SPEAKER_01: And that's true.
• 7:13
  SPEAKER_01: But the difference.
• 7:15
  SPEAKER_01: So humans make mistakes based either upon a lack of knowledge or an unintentional flup.
• 7:22
  SPEAKER_01: It happens.
• 7:22
  SPEAKER_01: We do it all the time.
• 7:23
  SPEAKER_01: In fact, as developers, our primary job is often to track down bugs, bugs that we often create ourselves.
• 7:30
  SPEAKER_01: So it happens.
• 7:31
  SPEAKER_01: We make mistakes.
• 7:32
  SPEAKER_01: We work to mitigate this by having more experienced developers who lead projects.
• 7:38
  SPEAKER_01: So that's why you see an awful lot companies asking for experienced developers or developers with a number of years of experience.
• 7:45
  SPEAKER_01: They're looking for people who have seen these things before, have experienced the problems, have worked it out, have filled in their lack of knowledge and learned how to round themselves out and learn how to avoid these bugs in the future.
• 8:00
  SPEAKER_01: These kind of people we pick to typically lead development projects.
• 8:05
  SPEAKER_01: And we also do code reviews.
• 8:07
  SPEAKER_01: So even with lead developers, we have up to read their code often because we need to make sure that you didn't make an accidental flub or you missed something and you have a gap in your knowledge.
• 8:18
  SPEAKER_01: However, that's not the dangerous type of mistake AI makes.
• 8:23
  SPEAKER_01: AI will leave things out.
• 8:25
  SPEAKER_01: It will make assumptions or it will just do things wrong because it's guessing.
• 8:31
  SPEAKER_01: But it will always make things look right.
• 8:35
  SPEAKER_01: It makes the logic sound correct.
• 8:39
  SPEAKER_01: So it's worse yet, it's going to create a working solution often that just looks right.
• 8:47
  SPEAKER_01: So back to that example of that web application.
• 8:50
  SPEAKER_01: It looked right.
• 8:52
  SPEAKER_01: The logic looked right.
• 8:54
  SPEAKER_01: Things worked.
• 8:55
  SPEAKER_01: It met the specification.
• 8:57
  SPEAKER_01: It was even protected.
• 9:00
  SPEAKER_01: But it was badly, badly wrong.
• 9:03
  SPEAKER_01: Wrong in a way that a developer wouldn't have done.
• 9:06
  SPEAKER_01: Or if they did, it was because they had very little experience in building applications.
• 9:13
  SPEAKER_01: Okay?
• 9:13
  SPEAKER_01: But because the fact the AI did it and it did it in a way that looked right, it actually made it worse because it enabled something really bad to go into production.
• 9:25
  SPEAKER_01: So that's the type of problem that AI creates.
• 9:31
  SPEAKER_01: The bottom line is this AI is a powerful tool and it can do great things.
• 9:36
  SPEAKER_01: Just be very careful not to start leaning on it as the source of truth.
• 9:41
  SPEAKER_01: Don't stop your search when AI gives you results.
• 9:45
  SPEAKER_01: Use that as a starting point.
• 9:47
  SPEAKER_01: Recently I asked AI, we had a discussion in the comments on my video on random, where one person said, well, point out the fact that random that has been instantiated with a seed was slower than random that was instantiated without a seed.
• 10:05
  SPEAKER_01: And so I went to verify that.
• 10:07
  SPEAKER_01: The first thing I did is I asked ChatGPT, is that true?
• 10:10
  SPEAKER_01: ChatGPT said, no, it's not true.
• 10:12
  SPEAKER_01: It uses the same logic for both of them.
• 10:15
  SPEAKER_01: The only difference will be that during the instantiation, it has to initiate that variable and set up and use that seed you pass in.
• 10:25
  SPEAKER_01: Therefore, it's a tiny little bit of difference in the instantiation.
• 10:29
  SPEAKER_01: Well, I use that as my starting point.
• 10:31
  SPEAKER_01: I went into code and create a benchmark where I benchmarked those two and found out that it's about five times slower to use a seed.
• 10:42
  SPEAKER_01: So it was totally incorrect.
• 10:45
  SPEAKER_01: But it sounded right.
• 10:46
  SPEAKER_01: It gave me the algorithm it used, all this information that sounded right.
• 10:51
  SPEAKER_01: Well, I go back to ChatGPT and I said, this is what I found.
• 10:54
  SPEAKER_01: And it said, you're exactly right.
• 10:56
  SPEAKER_01: Of course it did, right?
• 10:57
  SPEAKER_01: But it said, in.NET 6 this changed.
• 11:01
  SPEAKER_01: This used to be this way, but now this is the way, and now this is the algorithm, et cetera.
• 11:06
  SPEAKER_01: So if I had used ChatGPT as my source of truth, it was confidently wrong with great information.
• 11:14
  SPEAKER_01: Information that sounded right.
• 11:16
  SPEAKER_01: It was, it had all the information to document what algorithm it used and how it worked and how it created and what the tiny differences might be.
• 11:25
  SPEAKER_01: That's a problem, right?
• 11:27
  SPEAKER_01: So verify your results.
• 11:30
  SPEAKER_01: Use the results coming from the AI as the starting point.
• 11:34
  SPEAKER_01: Make sure you can validate there are no hidden flaws in the logic or its assertion.
• 11:40
  SPEAKER_01: For the people who start to get lazy and ignore this warning, they're gonna find themselves making a serious mistake before too long.
• 11:48
  SPEAKER_01: Make sure you don't fall into that trap.
• 11:51
  SPEAKER_01: Don't use AI as your source of truth.
• 11:54
  SPEAKER_01: Thanks for listening.
• 11:55
  SPEAKER_01: And as always, I am Tim Corey.
• 11:57
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 12:00
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to IamtimCorey.com and enroll in a course.