This is the first time I have written an article, or at least a post longer than 140 characters, and I am not sure how it will go. But I wanted to share an experience that mixes fatherhood, code, and learning.
Quick intro: my name is Rubén, I work as a software engineer at DataCamp, and five months ago I became the father of a little boy called Leo. It has been, and still is, the most wonderful and intense experience of my life. But I am not going to lie, life changes. Priorities change, time changes, and you have to adapt to survive.
A week ago I started my paternity leave. I have 11 weeks ahead of me. In Spain we get 17 in total, but I already took 6 when my son was born. So now I have 11 weeks full of adventure, time to get to know this tiny person in my arms a bit better, and, why not, also some time to keep building, learning, and contributing to open source.
Not in the fantasy version where I suddenly have full free days, of course. That does not exist. At least not in my house right now.
Free time does not exist
With a baby this age, many of you probably know this already, it is not easy to balance things or find time for anything else. In my case, I cannot really complain. I am still managing to keep some CrossFit sessions and the occasional padel match, although much less often than before.
But the day is no longer organized in big blocks. There is no quiet morning where I can sit down at the computer, open the editor, and disappear for four hours. There are bottles, diapers, walks, baths, play time, and moments where the only thing to do is just be there.
The free time I have left is basically the time when Leo sleeps during one of his many naps, between three and five a day. The longer ones can get close to two hours, but those are not the usual ones. The shorter and more frequent ones are around 45 minutes.
That has become my new work block: the nap.
The nap became my work session
I had a lot of side projects started, very few finished, and quite a few abandoned somewhere along the way. So I decided to use those naps to bring some of them back, rethink others, and give a nice goodbye to the ones that no longer made sense.
I was not trying to build a company, or make the big launch of my life, or become some kind of productivity machine. I just had projects I wanted to recover and a very specific kind of time: short, fragmented, and hard to predict.
With a basic Codex subscription and a basic Claude Code subscription, I thought I could orchestrate the work during naps and leave agents running until the next one. That was the initial idea, at least.
In practice, the interesting part has not been just using agents to write code. The interesting part has been changing the way I prepare work so agents can keep moving without me sitting in front of the screen the whole time.
Over time, that nap-based workflow turned into something more structured: a small personal harness of skills, documents, checks, and review loops. I will get into that in the next post.
The workflow
During the first nap of the morning, I choose the projects I am going to work on, usually two in parallel, and the workflow looks something like this:
- We analyze the project, its gaps, and its needs.
- We generate a PRD.
- We review that PRD and turn it into a roadmap.
Up to this point, it is a human-machine collaboration. I bring context, judgment, priorities, and limits. The agent helps organize, ask questions, spot gaps, and turn a half-formed idea into something that can actually be executed.
From there, the agent keeps working:
- It goes through the agreed roadmap items in order.
- It codes, tests, and tries the new implementations.
- It updates the documentation, the roadmap, and creates ADRs when needed.
During the next nap, it is time for code review and manual QA. This is the most boring part, but also the most satisfying one, because I get to try and validate the new features the agents have implemented. It is the moment where the project stops being a task list and starts feeling like mine again.
At that point, what I basically do is write a prompt back with structured feedback so the agents can refine or fix whatever did not land well the first time. It is usually not a very long process, except for a few cases, but it does require attention. You have to read the code, try the flow, catch where the agent assumed too much, and decide whether it is worth fixing, cutting back, or rolling back.
Then Leo wakes up from his nap, and the cycle repeats.
Nothing to brag about
Just to be clear, what I am describing here is not rocket science or the latest trend in AI engineering. It is just me adapting to my circumstances and trying to keep some continuity in conditions that are new to me.
Actually, I think that is the part I find most interesting. I do not feel like agents are replacing me as a developer. It feels more like they force me to move one level up for a while: think more clearly about what I want to build, write better specs, review with more intent, and accept that my work no longer always starts by writing code directly.
And deep down, I like it.
This is the first post in Nap-Driven Development, a series where I will share my experience with agentic systems, my workflow, spec-driven development, and the open source projects I am building along the way.
There is no big polished thesis yet. Just a weird season of life, a newborn, a few naps, and a lot of specs.
See you in the next post.
