← Writing

Why I built Pocket Notifier: hearing from coding agents while they work

· 4 min read

Most of my coding now happens through agents. I give Claude Code or Codex a task, it works for twenty minutes or an hour, and I do something else in the meantime. The tools already know how to tell me something: when the run stops, I get a notification.

That is the one moment I hear about, and it is often the least useful one. “Finished” tells me nothing about how it went. And a run that stops after five minutes because it needs me looks, from the couch, exactly like one that is still working. I would come back to find the agent had been waiting on a question for forty minutes, or had finished an hour ago, or had spent the time on the wrong branch of a plan I would have corrected at step two.

What I wanted was what I’d get from a person working on the task: a short message when each piece lands. Step 3 of 5 done, the tests pass. The review came back with two findings, none blocking. I need you to pick a cache. The build is broken and I can’t fix it. Nothing in between.

So I built Pocket Notifier.

Let the agent decide when

A hook that fires on every tool call would be noise, and one that fires on stop is what I already had. The interesting moments are only visible from inside the task: the agent knows that it just finished step 3, that the subagent’s result checked out, or that it is stuck on a decision only I can make.

So the notifier is an MCP server, and sending is a tool the agent calls. Connecting is one command and a browser sign-in:

claude mcp add --transport http pocket-notifier https://notifier.bartuozel.com/api/mcp

What makes it work is the agent skill that comes with it. It defines a milestone as a finished, checked unit of work: a plan step done, a verified subagent result, a component whose tests pass, a commit that closes part of the task, a review that came back. Starting something, reading files, a retry or “50% done” are not milestones. And every notification has to carry something measurable, like a step count, a test result, a number that moved, a PR or an exact failure. If the agent can’t name one, it doesn’t send.

That rule does most of the work. “Working on the API” is not a notification. “Step 2/5: API wired, 18 tests pass. Next: the app screens” is.

One thread per workstream

With a few agents running in a few repositories, one flat list of messages becomes unreadable fast. So messages are organized the way I track work. A project is a repository. A feature is one workstream in it, the thing I would open a ticket or a branch for, and in the app each feature is a chat thread.

One workstream, told as it happens The agent finds the thread for its task once, then posts each finished step there. A milestone is quiet, a question pops up, and the last message closes the thread.
  1. Coding agent to Pocket Notifier: list_features: reuse search-cache
  2. Pocket Notifier to Coding agent: feature found
  3. Coding agent to Pocket Notifier: Step 1/5 done, 12 tests pass
  4. Pocket Notifier to My phone: priority 2, quiet
  5. Coding agent to Pocket Notifier: Step 3/5: review back, 0 blocking
  6. Pocket Notifier to My phone: priority 2, quiet
  7. Coding agent to Pocket Notifier: ask: Redis or in-memory LRU?
  8. Pocket Notifier to My phone: priority 4, pops up
  9. Coding agent to Pocket Notifier: Done: PR #31 open
  10. Pocket Notifier to My phone: priority 3, Open PR button
  11. Coding agent to Pocket Notifier: update_feature_status: done

Before its first message, the agent lists the project’s features and reuses the one that matches its task. It keeps posting there for the rest of the workstream, across sessions, and marks the feature done when the work is merged. On my phone that reads like a short chat log of the task: what landed, in order, with the PR at the end. Opening a thread an hour later tells me the whole story without reading the agent’s transcript.

Quiet, unless it needs me

More notifications only help if most of them stay out of the way. Each priority is its own Android channel. Milestones go out at priority 2, which is silent and just sits in the shade. A finished task is a normal notification. A question or a failure is priority 4 and pops up on screen, because that is the one I should act on now.

When the agent is blocked, it sends an ask with the same two or three options it gave me in the session, and I can reply from the notification. The notification also carries a link back to where the decision lives, like the agent’s thread or the PR.

What it doesn’t do yet

The agent can’t read my reply. Answers from the phone are stored, but the MCP server has no tool to fetch them, so I still answer in the session. Closing that loop is the obvious next step.

It is Android only, and invite-only: one deployment on my own Cloudflare account, shared with a few people.

And the milestone rules are instructions, not enforcement. The agent decides what counts as finished and checked, and it is sometimes too chatty or too quiet. The measurable-result rule keeps that in check better than a cap on how many it sends, but it is still the agent’s judgment.

Even so, I now find out at step two that a task is going the wrong way, instead of at the end.