I have generated six different AI-powered learning roadmaps for Go in the past year. Each one was well-structured, personalized, and genuinely good. None of them survived past day three.
This isn’t a post about AI being bad for learning. It’s about a specific trap I kept falling into.
Everything Is Faster Now
Everything in tech moves faster than it used to. That’s not controversial. We write code faster. We ship faster. We find answers faster. The tools are better, AI is accelerating everything, and the industry moves at a pace that would have been unrecognizable five years ago.
And we’ve adapted. We genuinely pick things up faster than developers did a decade ago. That’s real.
But speed has a cost. When everything around you accelerates, you feel the pressure to accelerate too. New framework drops and you haven’t tried it yet. A colleague mentions a tool you’ve never heard of and suddenly you feel behind. The industry moves and you need to move with it, or at least that’s what it feels like. There’s this quiet anxiety humming in the background. Whether you’re learning the right thing (whatever “right” even means), whether you’re fast enough, whether you’ll become irrelevant if you stop moving.
And in that rush to keep up, something gets lost. We reach for tools and frameworks and concepts without fully understanding them. We get surface-level familiarity with twelve things instead of real understanding of one. We consume explanations that make perfect sense in the moment and evaporate by the next morning. I was no exception. I was moving fast. But I’m not sure I was actually getting anywhere.
This is especially painful if your brain is wired the way mine is. I studied mechanical engineering before I got into software. I didn’t end up working as one, but the training left a permanent mark. When I encounter something new, I can’t just use it. I need to understand how it works. Not the API. The mechanism. Why it was designed that way. What’s happening underneath. That need for depth is constantly at war with the pressure to go wide and fast. The result is a person who starts a lot of things and finishes approximately none of them.
The Loop
I’ve been writing PHP for about four years. A LOT of PHP. But I’ve had this itch to learn Go because I want to understand how the infrastructure tools I use every day actually work under the hood. The CLI tools, the CI/CD pipelines, the container orchestration, the devops stuff. Look at the cloud-native ecosystem and it’s Go everywhere: Docker, Kubernetes, Terraform, Prometheus, Helm. It’s the language that most of this world is built in.
Here’s how it always went. I’d get excited. I’d open Claude or ChatGPT and say “create me a roadmap to learn Go.” I’d tweak it a bit, make it mine. Plan ready. Time to learn.
Day one: I’m in the docs, writing little programs, feeling great.
Day two: setting up my editor, installing tools, taking notes.
Day three: I stumble on something completely unrelated. Maybe someone posts their Raspberry Pi homelab setup and I think “I should build one of those.” Maybe I read about Rust and think “wait, should I learn Rust instead?” Maybe a new DevOps tool shows up on Hacker News. And suddenly I’m down THAT rabbit hole, generating THAT roadmap, and Go is sitting in a forgotten terminal tab.
A month later, I’d circle back. “OK, for real this time.” New roadmap. New plan. Same result.
Six times.
And AI made the cycle frictionless. Thirty seconds and I have a beautiful, comprehensive plan for literally anything I’m curious about. The barrier to starting something new is zero. Which means the barrier to abandoning the previous thing is also zero.
Each time, I’d understand a little bit. Enough to feel like I was making progress. But it was Kahneman’s System 1 thinking: fast, intuitive, and shallow. It felt like learning. It wasn’t sticking.
Fred Brooks wrote in The Mythical Man-Month that nine women can’t make a baby in one month. Some things have an irreducible timeline. Understanding is one of them. You can speed up access to information, but you cannot speed up the moment where your brain actually wrestles with a concept and comes out the other side getting it. That moment takes however long it takes, and I kept trying to rush past it.
How It Started (The Zed Post)
Then at some point, Zed’s “Let’s Git Together” blog post came my way. Their team had paired with community contributors for eight weeks and shipped 66 Git improvements. They had a curated project board, weekly pairing sessions, biweekly demo days. People showing up consistently, working on the same thing, keeping each other moving.
Something clicked. Not about the program itself, but about the structure. The regularity. The showing up. Maybe I could find someone to learn with like that.
I found a colleague who was also interested in learning Go. We agreed to jump on a call a few times a week, a couple of hours each time. Loose plan: learn together, maybe eventually contribute to some open source.
First session. No roadmap. No chapter one. We opened a small Go project on GitHub (genuinely not great code, which honestly made it more fun) and just started reading it together. Line by line.
“OK so this is the main function I think.”
“What does that := thing do?”
“I think it’s like… shorthand for declaring a variable? Let me check.”
“Why is THIS function capitalized but that one isn’t?”
“OH. Oh wait. Is that the public/private thing?”
When we got stuck we asked Copilot. Got the answer, talked about it until we both understood it, and kept reading. Two people squinting at code and talking out loud.
It was SLOW. Way slower than reading an AI explanation. We spent twenty minutes on things an AI could have explained in twenty seconds. We went on tangents. We got things wrong and had to backtrack.
In a few hours I understood more about Go than in all my fast solo attempts combined. Because when I had to explain something out loud, my brain couldn’t coast. I had to organize the thought well enough to say it. And when I got it wrong, my colleague would go “hmm, that doesn’t sound right” and we’d dig into it together. That friction, the getting-it-wrong part, is where the understanding actually happened.
But beyond that, something I didn’t expect: I was enthusiastic. The feeling of pulling someone forward and being pulled forward at the same time. I couldn’t wait for the next session. That had never happened with any roadmap. And when someone is expecting me on Thursday, I can’t quietly wander off to research Rust or build a homelab. The commitment acts as a filter on my curiosity. It doesn’t kill it (nothing could), but it channels it.
How It’s Going
I still use AI every day. I used it today. I’ll use it tomorrow. I literally used AI to help me edit this article.
What I changed is small: I added a regular call with another person learning the same thing. That’s it.
We read open source Go projects together. We argue about what the code is doing. Sometimes we spend way too long on something. It’s not efficient at all.
Three weeks in, I haven’t abandoned Go. I haven’t jumped to some new shiny thing. I actually want to show up to the next call. For someone with my track record, that’s remarkable.
Maybe the problem was never discipline. Maybe it’s that everything around me was telling me to go faster, and I’d been listening. Some things can’t be rushed. Nine women, one month, no baby.
I didn’t need another roadmap. I just needed someone to be confused with, and be slow together.