✍️ Note to future me: progress counts, even when it happens in ten-minute slices.
The lie I kept telling myself
I used to think learning new dev skills required a quiet desk, long uninterrupted blocks, and a brain that was not busy tracking who just asked for water again.
Then I became a parent to two kids under 5. The calendar did not clear. The house did not get quieter. The desire to learn stuck around.
So I changed the model.
My new unit of progress: the small window
With small kids, time is not the real constraint. Continuity is.
I do not learn in evenings. I learn in:
- The 12 minutes before someone wakes up.
- The 20 minutes of quiet time that sometimes happens.
- The hour after bedtime that competes with dishes, laundry, and just being a person.
The win is not squeezing more hours from the day. The win is turning tiny windows into reps that stack up.
The real problem is context switching
Most of my learning falls apart when I treat it like entertainment. I watch a video, feel inspired, and then forget everything.
With kids, I cannot afford that. If I pick up a tool or concept, I need a way to:
- Stop instantly.
- Resume later without rebuilding my whole mental state.
That means I need artifacts.
The artifact rule
Every learning session ends with something I can come back to:
- A single note called “Next step” with one sentence.
- A saved failing test.
- A tiny repo with one working example.
- A screenshot of the error and what fixed it.
If I do not leave a breadcrumb, I will spend the next session just trying to remember where I was.
The highest-leverage artifact: a quick blog post
Of everything I leave behind, short blog posts help the most.
- They force me to explain the work in plain language, which exposes gaps.
- They create a narrative I can re-enter fast. Yesterday’s what, why, and next is right there.
- They are searchable, shareable, and motivating. Tiny wins add up when I can see them.
- They double as documentation for future me.
If I have 15 minutes, I would rather publish a 200-word build log than watch a 15-minute video. The post pays me back next time.
What I’m learning, and how I choose it
When time is tight, the wrong learning goal feels like punishment.
I filter topics with three questions:
- Will I use this in the next 30 days?
- Can I practice it in 15 minutes?
- Does it reduce future complexity or pain?
If it is “no” to all three, it goes on a parking list.
This is not about lowering ambition. It is about treating attention like a scarce resource.
My “parent schedule” learning loop
I do not rely on motivation. I rely on a loop:
- Capture
- Keep a running list of questions I hit while building.
- Pick one thread
- One question becomes the session. Not “learn Rust.” Instead: “Write a one-off script to seed the DB with three sample posts.”
- Build the smallest thing that proves understanding
- One endpoint. One component. One test.
- Write the next step before I stop
- Short enough that future me cannot pretend it is unclear.
- Optional but powerful: publish a quick build log
- 5 to 10 minutes to summarize what worked, what did not, and what is next.
This keeps the work from turning into a pile of half-starts.
The emotional part no one talks about
There is a special frustration that shows up when you try to learn after you have already given your best energy away.
Sometimes I sit down and realize I have:
- No patience left.
- No curiosity left.
- No brain left.
That does not mean I am failing. It means I am human.
On those days, I pick one of these:
- Read one page of docs.
- Refactor something tiny.
- Write down what confused me.
- Stop and sleep.
Sleep is not a reward. It is a dependency.
The surprising upside: kids force clarity
Kids do not care about abstractions. They care about results. That mindset rubs off.
Parenthood has pushed me to:
- Prefer simple solutions over clever ones.
- Make progress visible.
- Break problems into steps that fit real life.
That is not just parenting. That is engineering.
What success looks like right now
Success is not mastering everything.
Success is:
- Shipping small things consistently.
- Building a library of examples I can reuse.
- Staying curious without burning out.
- Being present with my kids and still growing.
- Hitting publish on short build posts that keep momentum alive.
My two kids under 5 will not remember whether I learned the new framework in 2026. They will remember whether I showed up.
I want to be the parent who shows up, and the developer who keeps learning. That is the balance I am practicing, one small window and one small blog post at a time.