Latest / DevQuestions with Tim Corey / 294. How Do You Protect Your Career from AI as a Software Developer?

Transcript

294. How Do You Protect Your Career from AI as a Software Developer? · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: There's a lot of uncertainty in software development right now.
• 0:03
  SPEAKER_01: People are concerned that AI might take their job.
• 0:05
  SPEAKER_01: They're concerned there aren't enough developer jobs to go around.
• 0:09
  SPEAKER_01: And they're concerned that the hiring market is broken, amongst other things they're concerned about.
• 0:15
  SPEAKER_01: And I think that people have a right to be concerned.
• 0:18
  SPEAKER_01: But I also think that now is a great time to become a software developer or increase your skills in software development outside of just using AI.
• 0:27
  SPEAKER_01: You just need to make sure that you protect your career.
• 0:31
  SPEAKER_01: Let's talk about it in today's episode of Dev Questions.
• 0:42
  SPEAKER_00: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:46
  SPEAKER_01: Software development is more than just writing code.
• 0:49
  SPEAKER_01: So let's talk about the rest of it.
• 0:51
  SPEAKER_01: Specifically, let's talk about how to protect your career as a software developer.
• 0:56
  SPEAKER_01: And let's start with the basics.
• 0:58
  SPEAKER_01: AI will be taking some jobs from people.
• 1:01
  SPEAKER_01: In fact, if you aren't careful, your job may be in jeopardy.
• 1:05
  SPEAKER_01: But it isn't because AI is doing something amazing or that it can do a software developer's job.
• 1:11
  SPEAKER_01: It isn't, and it can't.
• 1:13
  SPEAKER_01: Instead, what it can do is make you bad at your job.
• 1:18
  SPEAKER_01: So let's talk about how.
• 1:20
  SPEAKER_01: First, software developers solve problems.
• 1:24
  SPEAKER_01: We don't just write code.
• 1:25
  SPEAKER_01: And if you think that writing code is all we do, and that's all you can do, then yeah, you're in danger because you kind of miss the point of being a software developer.
• 1:37
  SPEAKER_01: A software developer isn't just told what to do and then do it.
• 1:41
  SPEAKER_01: Say, here's the bugs, fix the bugs.
• 1:43
  SPEAKER_01: Yes, sometimes our job ends up being that, and we kind of just focus in on that.
• 1:48
  SPEAKER_01: But really, a software developer's job is about figuring out how to provide value to the customer, figuring out how to accomplish a goal typically through code.
• 2:02
  SPEAKER_01: What's the difference?
• 2:04
  SPEAKER_01: Well, even if you have AI writing code, what code is it writing?
• 2:08
  SPEAKER_01: How does it know what to write?
• 2:09
  SPEAKER_01: How does it know to write the right code?
• 2:11
  SPEAKER_01: How does it know what decisions to make?
• 2:14
  SPEAKER_01: That all comes from somebody telling it what to do.
• 2:18
  SPEAKER_01: By somebody saying, here is a specification, here is what this should do, here's the guidance for doing this.
• 2:26
  SPEAKER_01: And yes, it needs a lot of guidance because no, AI is not a thinking process.
• 2:32
  SPEAKER_01: It does not evaluate in the way that we think about evaluation.
• 2:36
  SPEAKER_01: It doesn't make good architectural decisions on its own.
• 2:40
  SPEAKER_01: It needs to be guided in how it does things.
• 2:43
  SPEAKER_01: So if you're just here saying, I write code, well then yeah, AI is gonna write the code now or some of the code, especially if you let it, because when you say, hey, you just write this code and then ignore what it does, well, that's gonna be a problem.
• 3:01
  SPEAKER_01: You're gonna find yourself not doing a good job as a developer.
• 3:06
  SPEAKER_01: Along with this, developers are bad at code reviews.
• 3:11
  SPEAKER_01: This is something that has way before AI.
• 3:14
  SPEAKER_01: This is something that developers have struggled with and something that there have been studies on and people have observed.
• 3:20
  SPEAKER_01: And that is when a pull request comes in and you're assigned a pull request, if that pull request has one file changed and a dozen lines of code, more often people will very closely inspect those 12 lines.
• 3:38
  SPEAKER_01: They'll think about it, they'll evaluate it, they'll make sure that you're making the right choices, and they'll give good feedback.
• 3:44
  SPEAKER_01: However, if you turn in, let's say 10 files changed and a thousand lines of code changed, more often those pull request reviews consist of sounds good.
• 3:58
  SPEAKER_01: Yep, I think so.
• 4:00
  SPEAKER_01: Is it pass a test?
• 4:01
  SPEAKER_01: Good enough.
• 4:02
  SPEAKER_01: Where the developer reviewing the code didn't actually do any evaluation because he looked at how much was changed and went, that's a lot.
• 4:12
  SPEAKER_01: I'll just skim it.
• 4:13
  SPEAKER_01: And they don't actually do a thorough review.
• 4:16
  SPEAKER_01: And that's just human nature.
• 4:17
  SPEAKER_01: It's it's we look at something and say, that's overwhelming.
• 4:20
  SPEAKER_01: I'm gonna spend an hour or more reviewing that code, and I don't want to do that.
• 4:25
  SPEAKER_01: And so often, you know, pre-AI, those reviews were skipped or they were poorly done.
• 4:31
  SPEAKER_01: They were, you know, nitpicks were made, but no actual content was thoroughly reviewed.
• 4:38
  SPEAKER_01: And that can cause problems in a code base, which is why we say make small pull requests, make small changes rather than massive changes all at once, partly because it's easier to manage in our heads, our context window, but it's also easier for reviewers to understand what we did.
• 4:57
  SPEAKER_01: And it's easier to say, hey, this chunk didn't work, let's roll just that chunk back as opposed to the entire thing.
• 5:05
  SPEAKER_01: Here's the problem.
• 5:07
  SPEAKER_01: AI doesn't do that.
• 5:09
  SPEAKER_01: By default, the way AI will work is it will run, rate, write hundreds, thousands, tens of thousands of lines of code to address a problem.
• 5:18
  SPEAKER_01: And the more it does that, and the more you just start rubber stamping things, the worse it's gonna be.
• 5:24
  SPEAKER_01: Because now, what's your point of existence?
• 5:27
  SPEAKER_01: Why do you exist as a developer if you're just gonna say whatever the AI says is good?
• 5:33
  SPEAKER_01: Because it's not, I can tell you that.
• 5:35
  SPEAKER_01: The AI is consistently writing bad code, not all the time, but consistently.
• 5:41
  SPEAKER_01: Meaning there's gonna be a little bit of bad code pretty much everywhere.
• 5:45
  SPEAKER_01: You need to figure it out, find it, and change it.
• 5:48
  SPEAKER_01: You need to make sure that you review it and make sure that the AI is being consistent and how it's doing uh rules and how it's using code and how it's reusing libraries and other code you already have in existence.
• 6:01
  SPEAKER_01: There's so many things you need to do.
• 6:03
  SPEAKER_01: So you need to make sure that as a developer, you are working on being better at code reviews to actually review what the AI does.
• 6:13
  SPEAKER_01: Now, with this, the more you rely on AI, the less you remember.
• 6:20
  SPEAKER_01: It's like working out.
• 6:22
  SPEAKER_01: If you watch people work out, that's great.
• 6:25
  SPEAKER_01: Maybe you'll see a better way, a better form or something else.
• 6:28
  SPEAKER_01: But until you actually lift the weights, you're not building muscle.
• 6:32
  SPEAKER_01: So when it comes to development, if you're not actually doing the work, you're gonna start have seeing atrophy in your areas of software development.
• 6:43
  SPEAKER_01: Uh, a great example of this, if you've watched the movie WALL-E.
• 6:46
  SPEAKER_01: Um, it's, I believe, a Pixar movie.
• 6:49
  SPEAKER_01: And in the future, people leave Earth because Earth has been trashed, you leave a little robot behind, whole nother thing.
• 6:56
  SPEAKER_01: But if you watch the movie, you'll see that they have this progression where people start off like we are now, and they eventually end up living on these hover couches overweight and can barely do anything.
• 7:10
  SPEAKER_01: They can barely walk, they can barely stand, because of the fact they allowed more and more of the work to be done by a robot.
• 7:18
  SPEAKER_01: Well, that's kind of where we're at with AI, where the more and more of the work you allow the AI to do, the less and less skilled you will be if you don't continue to work out yourself.
• 7:32
  SPEAKER_01: So relying just on AI to do your work is going to mean that you're gonna atrophy in the areas of actually being able to do the job yourself.
• 7:42
  SPEAKER_01: So I think what I see people doing is they stop learning.
• 7:47
  SPEAKER_01: They stop practicing, they stop making sure they can do the work and they just allow the AI to do more and more of the work.
• 7:55
  SPEAKER_01: The problem is the AI doesn't do good work.
• 7:58
  SPEAKER_01: And I always hear people say, well, but it will in six months.
• 8:02
  SPEAKER_01: The next version of this next LLM will do a better job.
• 8:05
  SPEAKER_01: You know, there's all these code quality tests that you know, Claude or whoever else has passed, and it's so much better than developers.
• 8:12
  SPEAKER_01: No, it's not.
• 8:13
  SPEAKER_01: It is not perfect.
• 8:15
  SPEAKER_01: It is not good enough, even.
• 8:17
  SPEAKER_01: And it needs to be guided.
• 8:20
  SPEAKER_01: And so the more you rely on it, the more you're going to have bad code, and you also have less and less ability to remember how to fix that code.
• 8:31
  SPEAKER_01: So make sure that you are practicing.
• 8:35
  SPEAKER_01: And then don't stop learning.
• 8:38
  SPEAKER_01: People stop learning and start depending on the AI because why would I learn when the AI can tell you what to do?
• 8:44
  SPEAKER_01: In fact, why would you learn from an AI?
• 8:46
  SPEAKER_01: I've had people tell me, well, I'm just gonna learn from the AI.
• 8:49
  SPEAKER_01: What's the point?
• 8:50
  SPEAKER_01: Because the AI is confidently wrong some of the time.
• 8:55
  SPEAKER_01: And so you don't know where you're starting to add potholes in your memory.
• 9:00
  SPEAKER_01: And the thing is, people say, well, but everybody's wrong sometimes.
• 9:04
  SPEAKER_01: Yes, but the AI is confidently wrong enough, consistently enough, that you are, you know, maybe only 10% now, but that 10% plus the next 10% adds up over time.
• 9:15
  SPEAKER_01: Before you know it, you have 40%, 30% actual confidence in your skills.
• 9:22
  SPEAKER_01: You have so many gaps.
• 9:24
  SPEAKER_01: So don't stop learning because you'll start depending on the AI.
• 9:30
  SPEAKER_01: Now, the end result of all of this, when you say, you know what, I just let the AI write the code.
• 9:39
  SPEAKER_01: I don't really review it real well, I don't practice code development, and I have stopped learning new software development and just focus on the AI.
• 9:49
  SPEAKER_01: The end result of all this is that you're an auto-approving AI jockey who has no real value.
• 9:57
  SPEAKER_01: Because if all you're doing is saying, hey, do this, then if you've ever watched the movie Office Space, there is the guy that comes in to talk about why he justifies his jobs or his job.
• 10:11
  SPEAKER_01: And he tells the reviewer, he said, Hey, I take the information from the customer and I give it to the engineers.
• 10:18
  SPEAKER_01: And they're saying, Oh, so why can't the customer give it to the engineer?
• 10:22
  SPEAKER_01: And he's trying to justify why he needs to be in the middle.
• 10:25
  SPEAKER_01: And in fact, it's not actually him, it's his assistant, and that his assistant's actually just taking a fax and give it to the engineer.
• 10:31
  SPEAKER_01: Like we have bowl it all down, there's no reason for his job.
• 10:36
  SPEAKER_01: And that's where you will be if you're just an auto-approving AI jockey.
• 10:41
  SPEAKER_01: Because what's the point of having a developer, a highly paid developer, in the loop if they're just going to approve what the quality assurance person could have told them needs to be done?
• 10:55
  SPEAKER_01: Why can't the QA person just say, hey, AI, build this?
• 11:00
  SPEAKER_01: Right?
• 11:00
  SPEAKER_01: So if there's no added value, then what's the point?
• 11:05
  SPEAKER_01: And the more you just rely on AI, the less added value you provide.
• 11:11
  SPEAKER_01: And this is where I think there's a big deal coming in the industry where there's gonna be a lot of people who think they're developers, who even have years of experience as developers who can't do the job.
• 11:23
  SPEAKER_01: And that's a real uh opportunity for people who are willing to do the hard work.
• 11:30
  SPEAKER_01: So what should you do instead?
• 11:33
  SPEAKER_01: What can you do to make sure that you protect your career, to make sure that you aren't just falling into this trap of being like everybody else and slowly having your skills erode?
• 11:45
  SPEAKER_01: Well, number one, deepen your skills in software development.
• 11:49
  SPEAKER_01: That doesn't mean learn more AI.
• 11:51
  SPEAKER_01: We'll talk about AI in a minute because it's not something you ignore entirely.
• 11:55
  SPEAKER_01: But instead, deepen your skills in software development means learn more about your primary language.
• 12:03
  SPEAKER_01: For you know, this channel I teach C sharp, and I teach people go deeper into the language, learn more about, learn more at the nuances about how to understand and understand the trade-offs, understand how it works so you have a better understanding of what the choices are that you have when it comes to building an application.
• 12:23
  SPEAKER_01: You have more tools in your toolbox, deepen your skills, and with that also broaden your skills.
• 12:30
  SPEAKER_01: Add more skills where you know more about other areas and know what the alternatives are.
• 12:37
  SPEAKER_01: Now, number two is get better at architecture and code review.
• 12:43
  SPEAKER_01: Understanding how an application should be built, how it should be designed, how it should be structured is important.
• 12:49
  SPEAKER_01: Knowing how to put all these things together, knowing how to connect the pieces is important.
• 12:56
  SPEAKER_01: Knowing how to look at a situation, evaluate what might need to be done, what does need to be done, evaluating what's important and what's not, and then evaluating how to take code and other things to solve those problems is really important.
• 13:14
  SPEAKER_01: But with that, also code review.
• 13:16
  SPEAKER_01: You see, like I said before, being good at code review is always a struggle, even before AI.
• 13:23
  SPEAKER_01: If you can use this opportunity where AI is writing more code to practice and build your skill at code review, learn to be better at it.
• 13:34
  SPEAKER_01: You have lots of opportunity right now because the more AI writes code, the more opportunity you have to review someone else's code, the AI's code.
• 13:43
  SPEAKER_01: So learn to get better at it, learn to move beyond just rubber stamping things and evaluate what every line does.
• 13:50
  SPEAKER_01: Understand how your code is structured, how it works, and how it fits in the larger picture.
• 13:57
  SPEAKER_01: This is one of the areas that AI is really not good at.
• 14:01
  SPEAKER_01: If you see people developing AI, especially vibe coding, et cetera, you'll often see, almost exclusively see, people building new applications.
• 14:12
  SPEAKER_01: Why?
• 14:13
  SPEAKER_01: Because AI is a whole lot better at greenfield applications, meaning building something from scratch, compared to working within an existing code base.
• 14:25
  SPEAKER_01: It's it doesn't have the ability to put enough of the context in its brain.
• 14:30
  SPEAKER_01: And so often what you'll find is that it will change how your code is structured or how you do things, and and it won't follow your patterns that you have in the rest of your code.
• 14:41
  SPEAKER_01: Or it won't use some of the methods and some of the classes that you have in your code and will recreate those.
• 14:47
  SPEAKER_01: It'll violate dry all over the place.
• 14:49
  SPEAKER_01: It will violate a lot of things to put different architectures in place that don't really fit within the larger picture.
• 14:57
  SPEAKER_01: So understand how to review code and then with that have a better understanding of architecture so that you understand what's a good, well-written code base and what's not.
• 15:09
  SPEAKER_01: And so you can say, hey, this code might work on its own and it might be fine in another situation, but in this situation, we need to make a change.
• 15:20
  SPEAKER_01: And so learn how to do that.
• 15:23
  SPEAKER_01: Number three, learn more about trade-offs in development.
• 15:28
  SPEAKER_01: Too many developers have one solution for one problem.
• 15:34
  SPEAKER_01: When you say, hey, I need to put data in a database, and they say SQL, you're like, okay, but I haven't told you my situation yet.
• 15:43
  SPEAKER_01: Okay, tell me situation, but the answer is SQL.
• 15:46
  SPEAKER_01: Well, but I have this SQL.
• 15:49
  SPEAKER_01: See, that's not a good architectural standpoint.
• 15:53
  SPEAKER_01: That's not that's not good as a developer when you're saying, I have this solution for this, you know, this set of problems.
• 16:01
  SPEAKER_01: You need to make sure that you have more options.
• 16:04
  SPEAKER_01: Understand the trade-offs.
• 16:06
  SPEAKER_01: Understand when it might be the right choice for a NoSQL database.
• 16:10
  SPEAKER_01: Understand what might be the right choice for a MySQL database as opposed to a Microsoft SQL database.
• 16:16
  SPEAKER_01: Understand when it might be better to have Postgres, or it might be better to have CosmosDB or something else.
• 16:23
  SPEAKER_01: Understand the trade-offs.
• 16:25
  SPEAKER_01: That way you can make better decisions.
• 16:28
  SPEAKER_01: Number four, get better at catching AI mistakes.
• 16:33
  SPEAKER_01: If you think that AI doesn't make mistakes, then you're making mistakes.
• 16:39
  SPEAKER_01: And if you think that the code that AI writes is great code, then you're making mistakes.
• 16:46
  SPEAKER_01: Learn to catch the mistakes.
• 16:48
  SPEAKER_01: Learn to better evaluate what code the AI writes.
• 16:54
  SPEAKER_01: And then finally, prototype and build with AI.
• 16:58
  SPEAKER_01: Yes, you should continue to use AI, but you should lead, not let it lead.
• 17:04
  SPEAKER_01: So learn to be better at that.
• 17:06
  SPEAKER_01: Learn to be better at being in charge.
• 17:09
  SPEAKER_01: Use it to build and prototype things.
• 17:12
  SPEAKER_01: We talked about the idea uh before about last week about uh progressive web apps versus a native app.
• 17:19
  SPEAKER_01: And we talked about the idea that you have to sometimes prototype, make sure that these things can be done.
• 17:24
  SPEAKER_01: Well, that's a great place where you can tell an AI, hey, I want to do this, try that.
• 17:29
  SPEAKER_01: And maybe you just let it write, vibe code the whole thing.
• 17:32
  SPEAKER_01: Because the goal is not to create production-level code.
• 17:36
  SPEAKER_01: The goal is to see, can it be done?
• 17:39
  SPEAKER_01: And then evaluate what it does and read the code, evaluate how it worked and say, you know what, this is this is bad.
• 17:46
  SPEAKER_01: This shouldn't be done at all.
• 17:47
  SPEAKER_01: There's some security holes here.
• 17:49
  SPEAKER_01: Evaluate that, but use it to prototype, use it to build tools that you need.
• 17:55
  SPEAKER_01: There are certain things that just don't need to be production ready, heavily used.
• 18:00
  SPEAKER_01: They may just need to be a tool that runs on your PC or runs in your local network.
• 18:05
  SPEAKER_01: Build that with AI.
• 18:06
  SPEAKER_01: Learn how to get better at it.
• 18:08
  SPEAKER_01: Learn how to let it do more work while still adequately reviewing it, still looking at the architecture, looking at how it builds things, looking at how it writes the code, making sure that it writes good code, making sure it's not mistakes, making sure you evaluate security and make sure that you don't have, you know, go beyond just, does it have API keys in there?
• 18:30
  SPEAKER_01: Look beyond just that for security, but make sure that also is taken care of.
• 18:34
  SPEAKER_01: So these are things you can do that will help protect your career.
• 18:40
  SPEAKER_01: I just gave this advice to my nephew.
• 18:43
  SPEAKER_01: It's four words that can change your life.
• 18:45
  SPEAKER_01: Do the hard thing.
• 18:48
  SPEAKER_01: Everyone else will be taking shortcuts, or it feels that way.
• 18:51
  SPEAKER_01: But everyone else will be taking shortcuts and seemingly getting ahead.
• 18:56
  SPEAKER_01: Do the hard thing and be left standing when they've lost their jobs.
• 19:01
  SPEAKER_01: Okay?
• 19:02
  SPEAKER_01: Do the hard thing.
• 19:03
  SPEAKER_01: Put in the work.
• 19:04
  SPEAKER_01: Don't just take a shortcut.
• 19:06
  SPEAKER_01: Make sure that you're putting in the work, learning the how things work, not just how to push a button with an AI.
• 19:15
  SPEAKER_01: Do the hard thing and get ahead in your career.
• 19:18
  SPEAKER_01: Thanks for listening.
• 19:20
  SPEAKER_01: As always, I am Tim Corey.
• 19:22
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 19:25
  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.