I Used to Need a Team to Stay Organized. Now I Need a Loop.

The coordination I used to need a team for now runs as a loop I hold by myself. This is how I built it.

SUNDAY SHARE | ORCHESTRATION

Opinions are my own and do not represent my employer.

When I was a CMIO, I did the build and the work. I built inside Epic. I knew the config. I knew how to write the rules. I sat with the clinicians, then went back and changed the thing they needed changed. I was a Product Owner before anyone handed me that title. The title came later. The way of working came first.

I eventually built a team of doctors who knew how to do this too. That was how you scaled it then. You found clinicians who could hold both sides, the medicine and the build, and you taught them the config until the work could live in more than one set of hands.

I have written before that the CMIO role is really a Product Owner role wearing a clinical badge. That part transferred cleanly when I moved into managing clinical product work. What surprised me was the rest of it. The coordination. The status tracking. The “who asked for this and who closed it” bookkeeping that used to require a small team to hold together.

That part did not transfer. It dissolved.

The Problem Was Never the Missing Team

For years I assumed that running product at any scale meant staffing the coordination around it. Project coordinators. A status owner. Someone to chase the thread, file the request, update the board, write the release note. I treated that headcount as the cost of staying organized.

It was not.

The coordinators were never doing the deciding. They were moving information. They aggregated what came in, structured it into something a board could hold, routed it to the right person, then routed the outcome back out. That is real labor. It is also not judgment. Triage is judgment. Prioritization is judgment. The build is judgment. Everything in between was transport.

The problem was never that I lacked a team. The problem was that aggregation, structuring, and routing were manual, and manual work requires hands.

The Loop That Replaced the Layer

Here is what runs now.

I built a personal intake Claude Project called Clinical Product. I drop anything into it. A screenshot of a broken workflow. A thread. A half-formed thought about something I want to improve. Claude parses the mess into a structured record and files it to a Notion board, which is the front end of a Notion database where everything lives, gets managed, and gets worked from.

That intake is a triage queue. I sit with my leadership inside it and we do the one thing the old team could never do for us: decide. We triage. We prioritize. The queue is the table we make those calls at.

Then the work I can actually do, I do. Prompt changes, system changes, the configuration I personally own, all of it runs through its own Claude projects. When a batch is done, I ask Claude to summarize the completed work into a block, and that block becomes a clinic-appropriate release note that posts back into the channel where we close the loop.

Because Claude, Notion, and Slack are connected, the loop closes itself. One channel is the input. Notion is the system of record. The channel is the output again. Claude sits in the middle as the operating layer that moves between them. This is AI as OS in the most literal sense I have built yet. Not a feature inside an app. The connective tissue between apps.

The orchestrator decides. The model carries the load between decisions.

What the Loop Actually Changed

The lesson is not that I found a clever stack. It is that a function I assumed was fixed turned out to be optional, at least for how I work. Coordination felt structural. Once I built the loop, it stopped being something I had to staff around.

This is the Builder vs Legacy line, drawn through my own desk. The version of me that staffed coordination and called it rigor, against the version that runs the loop and spends the saved attention on judgment and on building.

And the part I did not expect: the loop credits people more precisely, not less. The old way lost attribution constantly. By the time a request traveled from the person who raised it through three handoffs to whoever built it and back, nobody remembered who asked and who built. My loop never forgets. Every release note names the person who surfaced the problem and the person who built the fix. The orchestration did not erase the humans. It made them legible.

One Caveat

The loop does not decide anything. It makes the inputs to a decision legible and the outputs of a decision distributable. Triage is still mine. Prioritization is still a conversation with my leadership. The build is still hands on a keyboard. Orchestration is not autonomy, and anyone who connects these tools expecting them to run product for them will get a faster, better-organized mess. The discipline has to exist before the wiring helps.

---

The way I worked as a CMIO never changed. I still do the build and the work. I still own the thing end to end. What changed is the price of working that way. The coordination that used to demand a team now runs as a loop I hold by myself, and the time I would have spent coordinating is time I now spend on the work that actually needs a human.

That is not a smaller job. It is a sharper one.

— Adam

If this resonated, the CMIO-as-Product-Owner thread is where this started.