Coding agents gave me a way to work around family responsibilities. Then they quietly followed me into every part of my life.

That is both the joy and the sorrow.

I am a father of two. One of my children is autistic, so our family schedule does not always follow office hours. There are errands, lessons, doctor and hospital visits, school visits, and ordinary days when a child simply needs a parent nearby. I am often away from my keyboard, even when the workday is still running.

I am fortunate to work remotely, and my company is okay with that reality. The harder negotiation usually happens inside my own head. When I use office hours for a family errand, I feel guilty. I tend to add more hours later to compensate, even when nobody asks me to.

For a long time, flexibility meant that I could move work to another part of the day. It did not mean the work could move without me.

Then coding agents arrived.

Reliable coding agents changed what it meant to leave my desk

The change became dramatic for me around Opus 4.5. Coding agents were no longer just impressive demos or autocomplete with a larger text box. Given a clear task and enough context, sometimes even less than I expected, they could work reliably for a useful stretch of time.

That changed the basic rhythm of software engineering. People began running several tasks at once. Multiple terminal windows became the new normal. A small software factory, with one person directing several agents, no longer sounded absurd.

My IDE also became less central. I still use it, but increasingly only as a code and diff viewer. More of the actual implementation now happens inside coding-agent sessions.

At first this felt like pure freedom. I could describe a task, start an agent session, and leave for a family responsibility. The work did not have to stop just because I stood up from my chair.

But there was an awkward catch. I now spent a surprising amount of time watching agents work.

I would start several terminal sessions, move between them, check whether an agent had finished, answer questions, then check another one. The agent was doing the coding, but I was still sitting in front of the screen waiting for the next handoff. This could not be the future of my work.

I had automated my hands but drained my attention.

A coding session did not need to live inside a terminal

The realization was almost embarrassingly simple: a coding agent session is mostly a conversation.

I send a prompt. The agent runs in the background. Later, I send another prompt and resume the same session. There is no fundamental reason for that conversation to depend on one terminal tab or a tmux session that I have to keep alive and remember where I left it.

Once I saw it that way, a web server became the obvious interface.

The server did not need to run on a public cloud. My own computer could run the agents privately. Through a private Tailscale network, another browser could reach it without turning my coding environment into a public service.

More importantly, a web server gave me a place to build the missing layer around the agents: persistent sessions, logs, status, attachments, and small but important details such as follow-up questions. A web app could provide one interface for different coding-agent tools. The agent process could come and go. The work around it could remain visible and resumable.

That idea became Tycho.

The first Remote UI prototype started in early May. It was a Progressive Web App (PWA) from the beginning because a desktop-only web interface would have missed the point. If I had to carry my laptop everywhere, I would only have rebuilt the terminal with worse shortcuts.

The phone was the real test. I wanted to start an agent before leaving, check it later, answer a narrow question, and return to family life without opening a laptop in the middle of an errand.

This worked.

I still wanted to look at the code

I am not a supporter of vibe coding, at least not in the sense of accepting whatever appears as long as the application seems to work. I still want to understand the code, even though I now spend less time reading it. That made a code viewer essential.

Agents have become better at summarizing changes, running tests, and returning the files I need to review. I can move a surprising amount of work forward from a conversation and a diff summary. The distance between me and the code grows a little at a time, not because I decided to stop reading it, but because every surrounding shortcut is convenient. The code viewer reminds me that I can always return to the actual code.

I chose boring Git clones over clever parallelism

Parallel agents need separate workspaces. Git worktrees are the common answer, but I never became comfortable with them. I kept hitting branch is already checked out and losing track of which folder owned which branch. Putting AI in front of a workflow I did not understand would only make the confusion faster.

So I use full clones in separate folders. They take more disk space, but each workspace is persistent, clear, and isolated. I can ask an agent to clone a repository, register the folder as a Tycho project, and continue using ordinary Git tools. It is boring, and that is why I trust it.

The whole setup worked. Perhaps too well.

Reducing the time agents wait for me

I cannot count how many hours I lost because I forgot to check an agent. I would start a task, move on to something else, and return much later only to find that the run had stalled because the agent needed clarification. The agent was waiting for me.

Push notifications became one of Tycho’s essential features. Instead of repeatedly opening Tycho, I could wait for a notification when an agent finished, failed, or needed clarification. More personally, I did not want to become the dad who was always looking at his phone while he was with his family. A notification could tell me when my attention was actually needed.

That was the theory.

In practice, agent notifications felt like social media on steroids. One coding agent could gently nudge me, but several agents turned those nudges into a stream of tiny demands: “Hey, look at me!” My phone no longer contained only messages from people. It also contained a queue of machines asking me to make decisions.

The first version treated completion as something worth announcing. Later I made routine completion notifications silent by default. I also grouped repeated agent updates instead of allowing every event to pile up as a separate visible notification. That is a technical detail, but it came from a personal lesson: not everything deserves my attention.

I wanted those notifications to free me from constant checking.

Coding anywhere slowly became coding all the time

Once Tycho lived on my phone, starting work became dangerously easy.

One tap opens Tycho and shows everything I am working on. I do not need to remember session names, navigate between terminal tabs, or keep the agent processes alive. Tycho stores the sessions so I can resume them later.

This is wonderful when family responsibilities interrupt a workday. I can leave the desk without losing all momentum. I can resume later without rebuilding the entire context in my head. That is the beauty of coding agents. Tycho makes that experience usable on a phone.

But this freedom has a cost. There is no clear line anymore between working hours and personal time. If I am holding my phone, I am also holding the control panel for every active project. An unfinished idea is always one tap away from becoming a running agent. It is so easy to start.

I find this genuinely addictive. I am still not sure how to stop it.

The strange result is that I now appreciate family time more because it is when I am naturally unavailable. When I drive, I cannot check my agents. Taking the children to swimming lessons gives both the agents and me a pause. Walking in the park becomes valuable partly because it is one of the few places where I can choose not to supervise anything. I supervise the kids, though.

Those activities used to look like interruptions to work. Now they feel like pockets of peace.

Building the tool creates its own infinite loop

There is a hidden temptation in building the tool you use for work.

When something in Tycho annoys me, I do not need to file a request and wait. I can use Tycho to spawn an agent that improves Tycho. It is a wonderfully satisfying loop for a builder.

It is also a distraction machine.

The work ranges from small choices, such as which icons represent agent status, to large ones, such as which coding-agent tools to support. All of these can make Tycho more dependable. But sometimes I need to reverse a decision. I may need to remove a feature or reject a solution that makes the tool too complex. I like those reversals because they prove the product is being used, not merely imagined.

That is the danger. When every rough edge becomes a task, a to-do, or even an epic, I can spend an entire day polishing the factory instead of shipping what the factory was meant to build. I still enjoy this loop as much as a session of Factorio.

Flexibility needs a boundary

Tycho solved a real problem for me. As a father of two, I cannot organize life as if uninterrupted desk time is the only valid way to work. Coding agents let implementation continue while I handle family responsibilities. Persistent sessions give me peace of mind because I can resume them at any time. Better yet, I do not need to carry a heavy laptop everywhere. I can work from an iPad at a cafe while connected to my laptop at home.

I do not want to give that up, but I need to limit how much the tool can intrude on personal moments. I made routine completion notifications silent. Tycho also skips notifications when an agent reports that no action is needed. That is the balancing act of designing a productivity tool: I built Tycho so work would not require me to remain at my desk. Now I must make sure it does not require me to be available everywhere I go.

Coding anywhere is a gift. Coding anytime is a choice. I am still learning to let the agents wait.

What about you? How do you keep work flexible without becoming permanently available?