How to Become Dangerously Self Educated (Complete Plan for A Developer) transcript

I want to take you back to a morning that I still think about. I'd been coding for maybe 8 months, self-taught, no degree, no computer science, none of the things everybody online swears you have to have. And I'm sitting at this cheap desk before the sun's up because that was the only time I had before the rest of my life started. And there's a problem on my screen that I cannot solve. And here's the thing that scared me.

It wasn't hard because it was advanced. It was hard because it wasn't in any tutorial. There was no video for it, no course module, no Stack Overflow answer I could paste in. It was just this weird, specific, tangled mess that only existed inside the thing I was building. And the only person who was ever going to untangle it was me. And I remember this cold little thought going through my head, "You're a fraud. You don't actually know how to do this.

You just know how to follow along." I want you to hold on to that feeling because everybody watching this has felt some version of it. And in 2026, with AI writing most of the code on Earth, a whole lot of developers are feeling it again, way harder than before. That quiet voice going, "The machine is better at this than me. So, what am I even for?" So, let me tell you what I figured out that morning and over the 5 years after it because it's the exact thing that took me from that scared guy at the cheap desk to a tech lead.

And it's the exact thing that's about to separate the developers who thrive in this AI mess from the ones who get quietly pushed out. And I promise you, it is not learn AI. Everybody's yelling that at you. It's almost the opposite. So, let's get into it. Let me actually rewind because I want to tell you my story so you can see the whole picture. I came to code late. I was 30. I had responsibilities. I had people counting on me, and I picked up programming not because I was some prodigy who loved computers as a kid.

I picked it up because I needed my life to change, and this felt like that one door that might open if I pushed on it hard enough. So, I did what you probably did. I found the courses, I found the tutorials, and I was good at them. I want to be honest about that because it fooled me for a long time. I could sit down with a 12-hour course and follow every single step in two speed. The instructor types, I type. The instructor explains, I nod.

At the end, the app works, and I feel like a genius. And then I try to build something of my own, something nobody had made a tutorial for, and I just freeze, blank. All that knowledge in my head, and the second there's no one telling me the next step, it was like the lights went out. I did that for months. I called it learning, it wasn't. I was collecting. I was hoarding little facts and patterns and syntax, stacking them up like if I just gathered enough of them, one day the pile would magically turn into skill.

It never turns into skill. Nobody tells you that. You can gather forever and stay exactly as stuck as the day you started. And I've watched a thousand people do it since, and I did it myself first. The morning I told you about, the bug with no tutorial, that was the morning the truth finally landed on me. Sitting there, sweating over a problem that only I could solve, I realized that everything I'd been learning wasn't the job.

Following along wasn't the job. Knowing the syntax wasn't the job. The job was this. The job was the exact thing I was worst at. The job was figuring out what to do when there is no answer look up. And once I saw that, I couldn't unsee it. It changed how I learned. It changed how I worked, and it's the reason I'm talking to you right now instead of still stuck at that little cheap desk. So, let me ask you something and really sit with it.

Why does a company pay a developer? Most people, if you catch them being honest, it's because you know things. You know the language. You know the framework. You can build the feature. So, the more you know, the more valuable you are. The safer your job is. That's the mental model almost everybody's running, and it's wrong. It's been wrong the whole time. We just got away with it because the machines couldn't do our jobs yet.

Here's [snorts] what a company is really paying for. They're paying for a bet. They're betting that when something goes sideways, something nobody planned for, something that isn't in any specs because the specs hasn't been written yet, you will be the person who figures it out. That's it. That's the whole thing. They're not paying for what you know today. They're paying for their belief that you can handle what nobody knows tomorrow.

Let me make that concrete because I lived it. When I finally got hired, the tickets that were fully spelled out do exactly this. Here's the design. Here's the endpoint. Those were the easy days. Anybody could close those. The days that mattered, the days that got me noticed and eventually got me leading a team, were the days somebody dropped something vague and ugly on my desk. The thing's slow and we don't know why.

The client wants this, but it kind of breaks everything else. Nobody understands this legacy code, and we have to change it by Friday. No tutorial, no answer to look up. Just terrain nobody had mapped. And the person who can walk into that fog and come out the other side with a plan, that person is worth almost anything to a company. That person doesn't get laid off. That person gets more. Now, sit with why that matter in 2026.

Because that fog, the machine can't do the fog. Not yet. And not for a while. And let me show you why. And the machine will create a lot of fogs. I've got a way I think about this. And it's helped a lot of people. So, let me hand it to you. Think about the difference between a GPS and someone who actually knows a city. The GPS is incredible. Type in where you want to go and it hands you every turn instantly. Better than you could work out for yourself.

For getting from a known place to another known place on roads that exist, nothing beats it. That is exactly what AI is for coding right now. You want a standard component, a common function, a well-worn pattern. Ask and it appears. Faster and cleaner than most humans can type it. That fight is over. I'm not going to pretend it isn't. But now, picture the roads closed. Picture the GPS is confidently completely wrong.

And if you've used these tools, you know they get confidently completely wrong all the time. Picture you're somewhere with no signal at all. In a part of the map that isn't really mapped. Who gets you home? The local. The person who actually knows the streets. Who's got the whole city living in their head like the back of their hand. Not as a list of turns, but as a real understanding of how it all fits together. Where it flows, where it jams up, what to do when the usual way is blocked.

AI is the best GPS that has ever existed. Your entire job from today forward is to become the local. And here's the beautiful part. The part I really need you to hear. Becoming the local does not require the machine to get any worse. It does not require you to out-type it. It's a different thing entirely. The machine getting better means somebody has to invent whole new breakthroughs in a technology that's got real walls it keeps bumping into.

You getting better, nothing has to be invented. You already own the equipment. Your brain can already learn a city. Most developers just never make it do that because following the GPS is so much easier. So, stop imagining you're in some sprint against the machine where it's faster and you're losing. You're not sprinting against it. You're building something it can't build, a map of the terrain that lives inside a human head.

And it is standing at a wall it cannot climb while you're on the other side, more than able to climb it, just not climbing yet. That's the whole game. Become the local. Let me show you the ground you're standing on first because 2026 is not a gentle year to be a passenger. Let me give you the real numbers because I won't lie to you about how this looks. At Google, roughly three quarters of the new code is now generated by AI and then approved by an engineer.

Across the whole industry, something like four in every 10 lines of new code is coming from a machine. Nearly every working developer on the planet is using these tools every single day. That's not a prediction. That's just Tuesday now. And here's the number that should sit you up straight. Entry-level developers job postings are down almost 30% from where they peaked. Meanwhile, the pay data tells this brutal little story.

Entry-level salaries are basically flat, barely moved while senior and staff pay is climbing several points a year. The money is walking up the ladder, away from the bottom, toward the top. The World Economic Forum put out a piece at the start of this year about what makes a developer valuable now. And I want to read you what was on their list. Speed of execution, thinking across different domains, being fluent with AI, adapting fast, actually shipping things.

And I want you to notice what was not on that list. Not code quality, not knowing a specific language inside out, not framework expertise, not years of experience. Those four things used to be the entire top of every job posting. That's what we all thought we were building. And they've been quietly shoved off the list and replaced with a completely different kind of thing. If I were starting today at 30, at that cheap desk, this is the world I'd be walking into.

And I'll tell you straight, if I did today what I did back then, if I spent my first year just collecting syntax and following along, I would not make it. That door I pushed on, it's a lot heavier now for the person doing it the old way. But it's actually easier for the person who understands what I'm about to tell you. So, let me keep going. There's a trap here, and I have to warn you about it because I watch sharp hard-working developers walk straight into it with a smile on their face.

The trap sounds like this. I use these AI tools and I get my work done in a fraction of the time now. I close my tickets twice as fast. I'm [ __ ] crushing it. Stop. That feeling of winning, that's the trap closing on you. Walk the logic all the way out. If the work that used to fill your whole week now takes you a day and a half, why would anyone keep paying you for the whole week? And when the tool gets a notch better next quarter, and the notch after that, why keep paying you at all?

The exact thing you're proud of, I made myself faster at my current work, is the exact math your company uses to decide it needs fewer people doing that work. You didn't make yourself safer. You made your current work cheaper. And then you tied yourself to it. I'm not telling you to stop using the tools. Use them. I use them every day. I'm telling you that speeding up the stuff you already do is not a strategy. It's a countdown.

The real question, the only question that keeps you employed, is what you do with the time the machine just handed you back. Because if the answer is the same low-level work, just more of it, you're still on the countdown. You just get to the end a little later. The developers who win take the freed-up time and pour straight into becoming the local. Everybody else takes that freed-up time and races the GPS. Guess who the company keeps.

Let me break the work itself into two piles. Because once you can see the two piles clearly, everything I'm telling you snaps into focus. There's the coding you can look up, and there's the coding you have to figure out. The lookup kind is anything with a known answer sitting out there in the world. The syntax, the boilerplate, the standard CRUD screen, the ticket that's already fully specified, where somebody smarter already made every decision and you're just the hands.

Memorizing the API, grinding a coding puzzle pattern so you can spit it back in an interview, converting some old code from one framework to another, all of that has an answer that already exists somewhere. And the machine can fetch and reshape existing answers faster and cleaner than you ever will. That entire pile now belongs to the GPS. If your value lives in that pile, you are right now competing with something that works for free, never sleeps, and gets better every few months.

That's not a fight, that's a wood chipper. Then there's the figure-it-out kind. This is where there's no answer sitting out there, because the answer depends entirely on your situation. This is deciding what to build in the first place and why, and what to leave out. This is looking at how a whole system fits together, where the data moves, where it'll strain, where it'll crack the day you get real users. This is sitting across from a product manager and telling them the plan is wrong and being right because you can see three moves ahead and they can't.

This is dropping into a codebase that's a haunted house nobody wants to touch and slowly building a picture of it in your head until it stops being scary. This is reading what the AI just confidently wrote and feeling in your gut and it's subtly broken and knowing exactly where to look. That pile is the moat and here's why it pays like it pays. It's hard for the machine. The machine hits the wall, but it's also hard for us.

Humans get overwhelmed by it, too. Too many pieces all connected, all pushing on each other and most people's brains just brown out and shut down. Yeah, they [ __ ] in their brains. So, the handful of developers who can hold all of it at once and stay calm in the fog get paid a fortune because everyone else taps out and hands them the hard problem. That's the pile you want to live in. That's the local. Now, here's where I made my biggest mistake and I don't want you making it.

So, let me confess it. For a long time, I believed these two piles were a staircase. I thought you started at the bottom, memorize the syntax, grind the puzzles, follow the tutorials, collect, collect, collect and that if I just climbed high enough on that bottom stuff, I'd eventually arrive at the good stuff. The figuring out, the system thinking. I thought it was a journey with a bottom and a top and you walked up.

It's not a staircase and this and this cost me real time to learn. The bottom pile does not lead to the top pile. They're two different skills that live in two different places and being incredible at the first one does not carry you 1 in toward the second. I've met developers who can recite framework internals like scripture and still freeze solid the moment you hand them something undefined. I was one of them. I could follow any tutorial on Earth and still stared at that bug like it was written in another language.

Because knowing a lot and figuring things out are just not the same muscle. So, when you spend all your energy down in the lookup pile, you don't slowly rise into the figured out pile. You just get really, really, really good at the exact thing the machine is here to eat. You max out. And the ceiling on that pile is dropping every single year. Because the GPS keeps getting better at lookup work. And it will not stop.

The developers who make it aren't climbing the bottom staircase faster than everybody else. They stopped climbing it. They walked over to a completely different staircase. The one almost nobody's on and started there. I'll show you how to get on that other staircase in a second. But first, I have to be straight with you about the AI itself. Because this is where the word in the title comes in. The dangerous part. Here's the thing nobody's telling you clearly enough.

AI for developer is a double-edged blade. Used one way, it is the fastest tool ever invented for becoming the local. Used the other way, it is the fastest way to make sure you never do. Same tool, opposite endings. And that's exactly what makes it dangerous. Because both ways feel productive while you're doing them. Let me show you it cuts both ways. Because I don't want you taking my word for it. There was a study this year where researchers watched experienced developers work.

Real, seasoned people. And some with AI tools and some without. And the findings shocked a lot of folks, including me. A lot of the experienced developers using AI actually got slower, not faster. Slower. Why? Because they stopped holding the map. They let the machine do the thinking. Took whatever it handed back and spent their day cleaning up after it instead of steering it. They traded their own understanding for speed, and it didn't even make them fast.

That's the rot, and it's quiet, and it's comfortable, which is what makes it so dangerous. Every time you let the machine do the reasoning, not the typing, the reasoning, the deciding, the figuring, a little bit of your own ability to do that goes soft. You feel like you're flying. You're actually shrinking. I felt it in myself on lazy days, where I let the tool drive, and then realize I couldn't have explained my own code to save my life.

That's the warning sign. If you can't explain what you shipped, the machine isn't helping you. It's replacing you, one decision at a time, with your permission. Now, the other edge, the good one, when I use these tools well, I don't ask them for answers. I use them to attack my own thinking. I'll make it hand me three different ways to build something, and then I make it argue against each one. I'll describe my plan and tell it to try to tear it apart, find where it breaks, tell me what I'm not seeing.

I'll take a piece of a system I don't understand and have it walk me through the terrain until the map in my head gets sharper. I stay the local. The machine just makes me a faster, sharper local than any human mentor could. At 3:00 in the morning, might I add. For free. That's the whole difference between a developer who's dangerously self-educated and one who's quietly getting replaced. One keeps the reasoning and uses the machine to sharpen it.

The other hands the reasoning over and slowly forgets how it felt to think. So, how do you actually get on the right staircase and stay on the right edge of the blade? Three things. They're the three things I'd go back and grab my younger self by the collar and force him to do. You can start every one of them today. The first one broke my brain when I finally got it, Because it's the opposite of everything school taught me.

Stop trying to understand it all before you build. I know exactly how you learn right now because it's how I learned for way too long. New tool, new framework, new concept, and the instinct is, "Okay, first I'll understand it. I'll finish the course. I'll read the docs. I'll really get it. And then I'll build something with it." It feels responsible. It feels like the adult careful way to do it. It's the slowest possible path.

And worse than that, it's a fantastic way to forget everything you just read. I'd spend a week understanding something and then sit down to use it and my head would be empty, wiped. Because understanding that isn't attached to anything real. If a piece of information doesn't connect to something you're actually doing, your brain decides it's junk and throws it out. Usually within minutes. So, flip the whole thing around.

Pick the thing you want to build, the real thing, the ugly first version, and start building it right now before you're ready, before you understand it. Let the machine hand you the boring scaffolding so your actual brain power goes where it matters. How do these pieces connect? Why is it shaped this way? What happens when this part fails? Here's what happens when you build first. The understanding shows up on its own and it shows up stuck because now every piece of knowledge has a job.

It's not floating. It's load-bearing. You needed it to make the thing work. So, your brain keeps it. When I stopped learning frameworks and started building broken, embarrassing little versions of real things with them, my progress went vertical. Not because I got smarter, because I finally gave my brain a reason to hold on. Build the broken version first. Understanding is what you get on the way, not the toll you pay to start.

The second one is going to sting a little and I say it with love because I did it, too. You do not need the perfect setup. You don't need the immaculate notes, the color-coded folders, the five monitors, the second brain app with everything tagged and linked, the 40 open tabs, the dream workspace before you're ready to really learn. That's not learning. That's decorating and decorating feels so good because it looks like progress and it never makes you feel stupid, which is exactly why we hide it.

Let me tell you the difference because it matters. There's a huge gap between being able to find something and actually knowing it. Beautiful notes just mean you can find things. Bookmarks, save snippets, a tidy folder. All that gets you is nicer filing cabinet. But when the fog rolls in and something's broken at midnight, nobody's got time to go rummaging through a filing cabinet. You need the city living in your head.

Knowing means you can shut your eyes and see how the whole thing fits. Where the data comes in, where it goes, what leans on what, where the cracks are. It means somebody asks you how the system works and you can draw it on a napkin from memory and explain it to a five-year-old. That's the local. That's the head you're trying to build and you don't build that head by filing things neatly. You build it by wrestling with how the pieces connect until it clicks.

So, grab a whiteboard or a scrap of paper or the back of a receipt and draw the system out from memory. I use draw.io. The boxes, the arrows, this talks to that, this depends on this, this is where it'll fall over. And when you get it wrong, you will and you have to wipe it and draw it again. That's not you failing. That's the exact moment your understanding is upgrading in real time. That redraw is the skill. That's the reps that matter.

The messy map in your head beats the gorgeous notes in your app every single time. Every time. Stop decorating and start knowing. [ __ ] up, mess it up, do it again. It's where you're leveling up. The third one is the smallest and it might be the most powerful. And it's the one that unlocks the most people when I teach it in a room. When you're staring at a hard design problem and you freeze, I want you to understand why you're freezing.

Because it's almost never the reason you think. You think you freeze because you're not smart enough or you don't know enough. Usually it's the opposite. You freeze because you can see it too many ways it could go. This connects here or here or over there. Five roads, all of them may be okay and you can't tell which one's right. So you just sit there spinning. Trying to solve the whole thing in your head at once. Stop trying to solve it in your head.

Your head is a terrible place to solve it. Get it out. Here's the move. Sketch one version. It's probably wrong. Sketch it anyway. Fast, ugly, no pride. Then sketch another one next to it. Then, and this is where the machine earns its keep, make the AI throw two or three more designs at you and pick them all apart. Now you're not staring at a fog. You're looking at four ugly options sitting side by side where your eyes can compare them.

And I promise you, half the time the answer jumps out the second it's in front of you. The answer you can never ever find while it was trapped inside your skull. Your sketch isn't the final answer. It's your thinking partner. It's the thing that lets you have the argument with yourself out loud, on paper, instead of drowning in it silently. And the developers who look like geniuses at system design, they're not the ones who nail it on the first try.

They're the ones who aren't scared to be wrong, ugly, and fast 10 times in a row until the right shape falls out. You have to look at it from a bird's eye view, sketch it, argue with it, throw it away, do it again. That's not a lack of talent. That's what the talent actually looks like up close. A while back, I made a video where I told you your bad memory doesn't matter in coding, and I know some of you didn't fully buy it.

I could feel it. Now, you can see why I meant it. Memory, recall, holding syntax in your head, being a walking reference, that's the deepest, lowest part of the lookup pile. It's the first thing the machine took. It was never where your value lived. It just took the GPS showing up and doing it perfectly for the rest of us to finally admit it out loud. Your bad memory was never the problem. Trying to win at the one thing that rewards memory, that was the problem.

You've been ashamed of the wrong weakness this whole time. So, let me bring it back to that cheap desk. So, let me bring it back to that cheap desk. Before the sun was up, 5 years and a whole life ago, the thing that saved me that morning wasn't knowing more. I didn't know more. The thing that saved me was deciding to stay in the fog instead of running from it. Deciding to be the person who figures it out, even when it's uncomfortable, even when there's no tutorial, even when the scared little voice is calling me a fraud.

That decision is the entire reason I went from that desk to leading a team. It's the whole thing. Coding saved my life, and it wasn't the syntax that did it. It was learning to think in the fog and in the dark. For years, being a self-taught developer meant you could survive on grind. Follow tutorial, close the ticket, keep your head down, stay useful. That floor is gone now. The machine has it. I'm not going to pretend otherwise, and anyone who does is selling you something.

But the ceiling, the figuring out the system in your head, the calm in the fog, the local who knows the streets, that ceiling is wide open. And it is worth more today than it has ever been in history of this field. The developers who own that are the last ones the machine touches. And right now, this month, they're the ones getting the offers while everybody else refreshes the job board. You already have the equipment for this.

You're born with it. I'm not asking you to become something you're not. I'm asking you to switch on the part of you that's been sitting there the whole time. Following the GPS when it could have been learning the city. Get in the fog on purpose. Build the broken thing. Draw the ugly map. Use the machine to sharpen your thinking, not to do it for you. Do that starting today, and none of this AI wave leaves you behind.

You become the one the wave can't touch. You become the local everybody comes looking for. I'll see you in the next one. And just remember, if I can do it, you can do it, too. Coding saves lives.