Skip to content
Back to the blog

· 7 min read

A weekly triage agent for a one-person studio: the portfolio system, ten days on

The follow-up to our portfolio case study. Capturing ideas worked so well that about eighty piled up unreviewed. Here is the flow we built so agents sort the backlog and one person makes every decision, the rules behind it, and what went wrong.

case-study · github · claude · agents · workflow

Where the last post left off

Ten days ago we wrote up how 1Zero9 runs its portfolio from one GitHub repository: a register of every project, ideas captured as Issues, and the same written rules in two AI assistants.

That post ended with a list of what the setup did not do. Two lines from it turned out to matter most:

  • It was a manual register, only as current as the last time someone updated it.
  • An approved idea still needed manual steps before anything happened.

Both got worse with use. This post is about fixing them, and about the mistake of thinking that the first version's success meant the system was working.

The problem

Capturing ideas became easy, so we captured a lot of them. In ten days the inbox reached about eighty open ideas. Everything that had been approved was built and closed. Nothing else had been approved, because nobody had reviewed it.

So the backlog was not unbuilt work. It was undecided ideas. One person was the project manager, the triage desk and the memory, and the triage desk was the part that never got staffed.

The register had the same disease. It listed around seventy repositories by hand, and most rows still said "Needs your input" because nobody had given it.

The flow

An idea now passes through six steps. The owner acts at two of them.

1. CaptureAn idea becomes an issue in one inbox2. Triage agent, weeklySuggests approve, park or close for each3. Owner decidesOne reply accepts or changes the calls4. Build agentOne approved issue becomes a pull request5. Owner approvesNothing ships until it is merged6. LogEach session records what changedOwner's decisionBeing built next

Agents do the sorting and the building. The two shaded steps are the only points where work waits for a person. Step four is not built yet, and the reason is in the order: an agent that builds is no use until something has been approved for it to build.

What we built

Five parts are live.

  • A generated register. A short script reads every repository from GitHub: its stack, what it proved we can build, when it was last pushed and where it is deployed. It replaces the hand-kept table from the last post.
  • A small judgement file beside it. The script cannot know whether a project is client work or a personal experiment, or whether it is live. Those calls sit in a separate hand-edited file that a rebuild never overwrites, each with a note of who decided and when.
  • Stage labels on the inbox. Next to idea and ready there are now in progress, blocked, waiting on client and parked, so open Issues show where work stands.
  • A weekly triage agent. Described below.
  • A captain's log. After any session that changes something, the assistant writes a dated entry: what changed, what was decided, what is open. The owner does not have to remember.

Four parts are still to come: the build agent, a brief for new projects that draws on past ones, a client request form that files straight into the inbox, and a weekly health check for live client sites.

The triage agent

It runs once a week on a schedule, with nobody watching. It reads the rules file and the register first, then the inbox.

For up to twenty-five ideas it suggests one call each:

  • Approve, with a priority, when the idea is clear, small enough to build, and on something live.
  • Park, when it is plausible but not now.
  • Close, when it is a duplicate, already done, or belongs to a project that has been archived.
  • Needs the owner, with the question in one line, when it involves money, a client relationship, or deleting something.

It posts the result as one Issue, written to be read on a phone. The report opens with what is already in flight, so it also answers "what are we dealing with now?"

The owner replies once: accept for everything, or a list of changes, or skip. The following week's run applies what was accepted before it writes the next report.

The agent is not allowed to push code, merge, deploy, or contact anyone. It may not mark anything approved, or close anything, unless the owner accepted that call. And it treats everything it reads in an Issue as data. Only a reply from the owner's own account counts as a decision.

At the time of writing the first report is due this evening. We will update this post with how the first full cycle went.

The rules that mattered

  • Nothing approves itself. Agents suggest and build. A person approves ideas and merges code.
  • One source of truth per question. One register, one inbox, one rules file. When we found a second copy of anything, we removed it.
  • Generated beats hand-kept. Facts are read from the source. Only judgement is typed by hand.
  • One piece at a time. A new piece is built only if it takes a job off the owner, and it is tried on one project before the rest.
  • Few things in progress. No more than three pieces of work are open at once.
  • Write it down. Every session that changes something leaves a log entry.

What went wrong

As before, this is the useful part.

  • The first design had five agents in a chain. An intake agent, a planner, a builder, a reviewer and a manager. It looked thorough. The studio's own earlier experiments had already tested that kind of orchestration and not found it worth the overhead, and that evidence was sitting in a file nobody had opened. It was cut to one agent doing one job.
  • A second register was built before anyone checked that one existed. For about an hour there were four overlapping lists of the same repositories, which is the mess the whole system exists to prevent. The fix was to merge them into one. The lesson was to read what is there before adding to it.
  • The register was rebuilt while offline and published almost empty. The script could not reach GitHub, wrote a file listing three repositories where there should have been seventy-four, and that file was committed and pushed. The script now refuses to run when it cannot reach most of the repositories, and keeps the last good copy.
  • The backlog was misread. We assumed eighty open Issues meant eighty things to build, and started designing a builder. Looking at the labels showed that none of them had been approved. The right first agent was the one that helps decide.

What it does not do

  • It does not build anything yet. Approved work is still done in a normal assistant session.
  • The triage agent's calls have not been measured. Until a few weekly cycles have run, we do not know how often the owner overrides it.
  • The register is rebuilt by running a script on one machine. Moving that to GitHub Actions is next.
  • Client requests still arrive by message and are filed by hand.

Try it

If you already have ideas going into one inbox, start with the question we got wrong: how many of your open items has anyone actually approved? If the answer is "few", you do not need an agent that builds. You need one that brings you a short list of decisions each week, and a rule that it cannot make them for you.