There was a time when a senior engineer would tell a newer developer: "Build side projects. Ship things. That's how you learn."
It was good advice. For decades, it was the clearest path from "reading about code" to "understanding code." You built something real. You hit a wall. You figured out how through the wall. You shipped. You learned.
That advice still gets given. It still gets followed. And for the first time in a long while, it's not working the way it used to.
What Changed
Side projects used to be a learning environment. Now they're a performance environment.
When everyone with a laptop can spin up a full-stack app in an afternoon with AI assistance, "I built a side project" stopped being a meaningful signal. Not because the project itself is worthless — but because the proof of learning it used to represent got severed from the activity.
You can build a side project. You can ship it. You can put it on GitHub. You can list it on your resume.
And a senior engineer looking at it will ask a different question than they used to: not "did they ship something?" but "did they learn something building it?"
That question is harder to answer now. Because learning looks different when the hard parts got handled by an AI.
The Three Ways Side Projects Broke
1 The barrier to shipping collapsed. The barrier to learning didn't.
The old model: You didn't know how to build auth, so you spent three days fighting it, read four tutorials, made ten mistakes, and finally got it working. You understood auth at the end because you understood every way it could fail.
The new model: AI builds auth in ten minutes. You ship it. It's correct. You move on.
What happened to the three days of struggle? They disappeared. So did the understanding.
This isn't an argument against AI. It's a description of what gets lost. The struggle was the learning, not the shipping. When the struggle gets automated, you can still ship — but you learn less per project.
2 The portfolio signal inverted.
Somewhere around 2024, the side project on a resume stopped being unusual. Recruiters started seeing dozens of "full-stack AI apps" from candidates at every level. The project itself stopped differentiating.
What recruiters started looking for instead: evidence of depth. Not "built a thing" but "built something well." Not a list of technologies but a demonstration of judgment.
The problem: the side project format doesn't naturally produce that evidence. It's a finished artifact, not a window into how someone thinks. And when the project was built mostly with AI assistance, the artifact doesn't even reliably show the candidate's actual skill level.
3 The motivation structure reversed.
Building side projects used to require a certain kind of internal drive. You had to be willing to sit alone with a hard problem for hours, fail repeatedly, and keep going. That process built more than code — it built the identity of someone who could handle hard problems.
AI didn't just make building easier. It made the motivation to build thinner. Because you no longer need to build side projects to prove you can handle hard problems — you can show you can handle hard problems in your actual job using AI tools.
The side project used to be where you developed the resilience that made you valuable. When it became easy to skip the resilience, the resilience stopped developing.
The Gap Nobody Named
There's a specific experience a lot of engineers are having right now that doesn't have a clean name yet.
It goes like this: you want to grow. You know you should be building things. You sit down to build a side project. You use AI to get it working. It works. It's fine.
You feel nothing.
Not satisfaction. Not pride. Not the "I figured that out" feeling that used to make the hours worthwhile.
It shipped. It exists. It doesn't feel like yours.
So you stop mid-project. Or you finish it but don't update your resume. Or you start a new one and repeat the cycle.
This is what "just build side projects" looks like now for a lot of people: a hollowed-out exercise that produces artifacts without producing growth.
Why This Hits Senior Engineers Hard
You'd think this would be a junior problem. Here's why it's not.
A senior engineer's identity was built on the evidence of having figured things out. The side project used to be another data point in that story: I saw a hard problem. I sat with it. I solved it.
When you build a side project with heavy AI assistance, you don't get to tell that story to yourself. You solved it — but you didn't figure it out. And your own nervous system knows the difference, even if you can't articulate it.
This creates a strange double-bind: you're supposed to be using AI tools (the industry expects it, the work demands it, the market rewards velocity). But using AI removes the thing that used to make your growth feel real.
You're producing more and growing less. And the side project — the old reliable growth mechanism — stopped being able to bridge that gap.
The Other Problem: The Gap Compounds
Engineers who learned the old way — by building, failing, iterating — developed a kind of learning muscle. When they hit something new, they knew how to sit with discomfort, push through not-knowing, and eventually emerge with genuine understanding.
That muscle atrophies without use.
When you hit every new technology with an AI assistant, the muscle doesn't get used. The discomfort gets bypassed. You skip the not-knowing and arrive at the answer.
This works fine for a while. You stay productive. You ship things. You perform well.
But the muscle is atrophying quietly. And when you finally need it — when the AI can't answer the question, when the problem doesn't fit the pattern, when the thing you've been outsourcing suddenly needs you to have opinions about it — that's when you notice the gap.
The side project used to be the workout that kept the muscle strong. Now the side project is also getting automated away.
What Actually Fills the Gap
This isn't "give up on side projects." It's "the side project alone isn't enough anymore."
The projects that still produce growth are the ones where the hard part is opinion, not implementation. Architectural decisions. Design choices. Trade-offs where there's no right answer — only your answer, based on your understanding of the context. AI can generate code. It can't generate taste. It can't generate judgment. It can't generate the thing you believe about what good looks like and why. The side project worth building is the one that forces you to have opinions about things that matter.
After you build something with AI, open a blank editor and rebuild the hardest part without any assistance. Don't ship it. Just see what you actually know. The gap between what you built with AI and what you can build without it is the real signal. It's uncomfortable to look at. But it's the most accurate measure of what you actually learned.
The thing that most reliably closes the calibration gap is explaining what you built. Not documentation — documentation can be AI-generated. Teaching: walking someone through why you made the decisions you made, what alternatives you rejected, what you got wrong, what you'd do differently. Teaching requires you to understand the why, not just the what. A side project you can teach about is a project you actually learned from.
You don't need three hours a day. You need twenty minutes of deliberate struggle with something hard enough to require it. Not because struggling is virtuous — because struggling is the mechanism by which understanding gets encoded. Once a week: build something without AI, even if it's small. Even if it's slower. Even if it produces less. Keep the muscle alive.
"There's a version of this that's just anxiety. And there's a version that's a genuine structural problem: you are producing more than you're learning, and the side projects that used to close that gap aren't closing it anymore."
The difference between those two versions is the same: can you build the hard part without assistance or not?
Goes deeper into the mechanism of why keeping up with AI tools feels like learning but isn't — and what to do about it.
📬 Get The Dispatch in your inbox every week.
Stories and frameworks for engineers who use AI tools and want to stay sharp.
Subscribe — it's freeJoin engineers who've reclaimed their craft, one issue at a time.
Next week: The real cost of "just keep shipping."