WEBVTT

00:00.000 --> 00:01.500
Welcome to The Explainer.

00:01.500 --> 00:04.300
Today, we're diving deep into AI co-pilots.

00:04.300 --> 00:05.960
And we're not just talking about the hype.

00:05.960 --> 00:08.460
We're looking at how these tools are really changing the game

00:08.460 --> 00:10.920
for software developers, the good, the bad,

00:10.920 --> 00:12.540
and everything in between.

00:12.540 --> 00:15.180
All right, let's just jump right in with a quote that,

00:15.180 --> 00:17.600
well, it pretty much says it all.

00:17.600 --> 00:18.680
Imagine this.

00:18.680 --> 00:20.920
You ship a feature in three days,

00:20.920 --> 00:24.100
a feature that your team thought would take two weeks.

00:24.100 --> 00:25.520
Think about that for a second.

00:25.520 --> 00:27.220
That's not just a little bit faster.

00:27.220 --> 00:29.060
That's a total transformation.

00:29.360 --> 00:30.600
And how they do it?

00:30.600 --> 00:32.960
It wasn't about working crazy hours or cutting corners.

00:32.960 --> 00:33.800
Nope.

00:33.800 --> 00:36.240
It was about an engineer who made their AI co-pilot

00:36.240 --> 00:38.120
a true partner in the process.

00:38.120 --> 00:39.600
But here's the thing.

00:39.600 --> 00:42.600
That quote, it's not just about speed.

00:42.600 --> 00:44.040
That's the real kicker.

00:44.040 --> 00:46.040
Because when you bring these tools in,

00:46.040 --> 00:48.640
you're also introducing brand new kinds of bugs,

00:48.640 --> 00:51.520
you're forcing a complete overhaul of team processes,

00:51.520 --> 00:53.660
and you're fundamentally changing what it even means

00:53.660 --> 00:55.100
to be a good developer.

00:55.100 --> 00:57.680
It's a whole new playbook.

00:57.700 --> 01:00.580
Okay, so to really get our heads around this shift,

01:00.580 --> 01:02.500
let's do a little reality check.

01:02.500 --> 01:05.300
We need to be super clear on what these tools are,

01:05.300 --> 01:08.500
and maybe even more importantly, what they aren't.

01:08.500 --> 01:10.140
So you might be thinking, hang on,

01:10.140 --> 01:11.980
haven't we had autocomplete forever?

01:11.980 --> 01:12.940
And yeah, you're right,

01:12.940 --> 01:15.260
but this is a whole different beast.

01:15.260 --> 01:17.340
The secret sauce here is that these tools

01:17.340 --> 01:20.220
use large language models to understand your intent,

01:20.220 --> 01:21.880
not just your syntax.

01:21.880 --> 01:23.940
You can literally just tell it what you want

01:23.940 --> 01:24.780
in plain English,

01:24.780 --> 01:27.660
and poof, it translates that into working code.

01:28.480 --> 01:30.040
It's a completely different level of partnership.

01:30.040 --> 01:32.900
And this is absolutely crucial.

01:32.900 --> 01:35.080
These things are not magic ones.

01:35.080 --> 01:37.760
They're not gonna make big architectural decisions for you

01:37.760 --> 01:40.800
or understand your company's unique business goals.

01:40.800 --> 01:42.460
They can suggest stuff for sure,

01:42.460 --> 01:44.800
but they don't replace human judgment.

01:44.800 --> 01:45.800
Think of it this way.

01:45.800 --> 01:48.160
The developer is still very much the pilot.

01:48.160 --> 01:51.420
The AI is the co-pilot, not the one flying the plane.

01:51.420 --> 01:53.520
And if you're wondering if this is just a fad,

01:53.520 --> 01:57.200
well, just look at this number, 76%.

01:57.220 --> 01:59.860
That's not some small group of early adopters.

01:59.860 --> 02:02.620
That's the vast majority of professional developers

02:02.620 --> 02:04.420
already using these tools.

02:04.420 --> 02:05.780
So yeah, the question isn't

02:05.780 --> 02:08.620
if teams will use them anymore, it's how.

02:08.620 --> 02:11.580
This is just part of the modern developers toolkit now.

02:11.580 --> 02:14.900
Okay, but where are we actually seeing the wins?

02:14.900 --> 02:16.940
This is where it gets really fascinating.

02:16.940 --> 02:19.540
For all that boring, repetitive stuff,

02:19.540 --> 02:21.560
writing the same old boilerplate code,

02:21.560 --> 02:22.900
churning out unit tests,

02:22.900 --> 02:25.780
the speed up is huge, a 50% boost.

02:25.800 --> 02:28.440
But when you get to the really gnarly problems,

02:28.440 --> 02:30.460
like hunting down a super tricky bug,

02:30.460 --> 02:32.480
the benefit is a lot smaller.

02:32.480 --> 02:33.640
So what's that tell us?

02:33.640 --> 02:36.440
The AI is an amazing accelerator for the grunt work,

02:36.440 --> 02:38.880
but it's not a silver bullet for the hard stuff.

02:38.880 --> 02:41.600
But all that speed, well, it comes with a catch,

02:41.600 --> 02:43.640
a kind of hidden tax, if you will.

02:43.640 --> 02:45.960
Because when a co-pilot spits out 50 lines of code

02:45.960 --> 02:47.720
in two seconds flat, guess what?

02:47.720 --> 02:50.560
A human still has to read it, understand it,

02:50.560 --> 02:51.480
and approve it.

02:51.480 --> 02:53.600
And that's where this 20% comes in.

02:53.620 --> 02:56.680
That's the extra time teams are spending on code review.

02:56.680 --> 02:59.760
You're basically trading typing time for thinking time,

02:59.760 --> 03:02.420
making sure what the AI wrote is actually correct,

03:02.420 --> 03:03.980
secure, and makes sense.

03:03.980 --> 03:06.480
Which brings us to probably the biggest,

03:06.480 --> 03:09.340
thorniest debate happening in engineering right now.

03:09.340 --> 03:12.820
Are these tools actually making our code better?

03:12.820 --> 03:15.220
Or are they quietly planting ticking time bombs

03:15.220 --> 03:16.640
in our code bases?

03:16.640 --> 03:19.420
And man, you can really see the tension here, right?

03:19.420 --> 03:22.880
On one side, the argument for better code is pretty strong.

03:22.900 --> 03:24.940
You can get everyone writing in a consistent style

03:24.940 --> 03:26.980
and just look at that jump in test coverage.

03:26.980 --> 03:28.340
That's huge.

03:28.340 --> 03:31.100
But then there's the other side of the coin.

03:31.100 --> 03:33.460
The danger of developers just copying and pasting code

03:33.460 --> 03:34.980
they don't really understand.

03:34.980 --> 03:37.060
Or even worse, the AI introducing

03:37.060 --> 03:38.620
these tiny, subtle security holes

03:38.620 --> 03:40.540
that look fine on the surface.

03:40.540 --> 03:42.300
It is the classic double-edged sword.

03:42.300 --> 03:45.500
Okay, so you've got this amazing promise on one hand

03:45.500 --> 03:47.740
and this pretty scary peril on the other.

03:47.740 --> 03:51.200
How do you actually rule this out without blowing things up?

03:51.200 --> 03:52.760
Because it's definitely not as simple

03:52.760 --> 03:56.060
as just giving everyone a license and saying, have fun.

03:56.060 --> 03:57.500
Well, the smart way to do it

03:57.500 --> 03:59.680
seems to be this kind of phased plan.

03:59.680 --> 04:01.920
You don't go big bang, you start small

04:01.920 --> 04:03.980
with a team that's actually excited about it

04:03.980 --> 04:05.940
and you measure everything.

04:05.940 --> 04:08.860
Then, and listen, this is the most important part.

04:08.860 --> 04:12.000
You have to change your process before you scale it out.

04:12.000 --> 04:13.900
Your old code review checklist,

04:13.900 --> 04:15.580
probably not gonna cut it anymore.

04:15.580 --> 04:17.980
You have to build a whole new support system for the tool,

04:17.980 --> 04:19.820
not just throw the tool at your old system

04:19.820 --> 04:20.900
and hope it works.

04:20.920 --> 04:24.200
So all of this, the new tools, the new processes,

04:24.200 --> 04:26.400
it leads to a pretty profound question.

04:26.400 --> 04:28.760
What does it even mean to be a developer now?

04:28.760 --> 04:30.040
Because let's be real,

04:30.040 --> 04:32.840
the skills that made you a rock star coder 10 years ago,

04:32.840 --> 04:35.600
they're not necessarily the ones that matter most today.

04:35.600 --> 04:38.560
So what skills do matter?

04:38.560 --> 04:41.200
The value is shifting big time.

04:41.200 --> 04:43.800
It's becoming less about how fast you can type

04:43.800 --> 04:46.240
or whether you've memorized every piece of syntax.

04:46.240 --> 04:49.320
It's now all about the things the AI can't do.

04:49.320 --> 04:50.700
Can you think about the big picture?

04:50.720 --> 04:51.840
The architecture.

04:51.840 --> 04:54.160
Can you ask the AI smart questions?

04:54.160 --> 04:55.640
And can you look at what it gives you back

04:55.640 --> 04:58.120
and say, nope, that's not quite right?

04:58.120 --> 05:01.100
Basically, the code itself is becoming a commodity.

05:01.100 --> 05:04.000
The real value is in the thinking behind the code.

05:04.000 --> 05:07.000
And that really brings us to the final critical question

05:07.000 --> 05:09.320
you have to ask yourself and your team.

05:09.320 --> 05:11.720
AI co-pilots are here, they're powerful,

05:11.720 --> 05:12.980
and they're not going anywhere.

05:12.980 --> 05:13.820
But at the end of the day,

05:13.820 --> 05:17.960
their impact depends entirely on how you choose to use them.

05:17.960 --> 05:19.880
Are you just using them to type code faster?

05:19.900 --> 05:22.660
Or are you using them to free up your brain to think bigger,

05:22.660 --> 05:25.100
to focus on building truly great systems?

05:25.100 --> 05:27.020
Because that choice right there,

05:27.020 --> 05:28.900
that's what's going to define the next era

05:28.900 --> 05:30.100
of software development.

