---
title: The Relay Board — my agent runs the GitHub kanban, I just close my cards
date: 2026-09-10
tags: [ai-agents, github-projects, workflow, project-management, claude-code]
type: success
reproducible: true
stack: GitHub Projects, gh CLI
agent: Claude Code
model: claude-opus-4-8
image: https://worklore.dev/images/relay-board.png
image_alt: A GitHub Projects board titled Relay Board with three columns — Todo, In Progress, Done — cards colour-coded by owner (orange for the human, blue for the agent).
---

# The Relay Board — my agent runs the GitHub kanban, I just close my cards

Building a connector with my agent, I kept losing the thread. I'd say "do the
server, then the OAuth," and two messages later neither of us could say what was
done, what was mine, and what was blocked. The chat was our only shared memory —
and it's a terrible board.

Two things kept biting me. I couldn't hold the whole project in my head: without
a picture in front of me I was rebuilding the map every time — what's left, what
depends on what — from memory. And real projects don't fit in one session. Come
back two days later, or switch to another repo and back, and recovering the
context from chat is a command plus a wall of scrollback. I wanted one glance
instead.

So we moved the whole plan onto one GitHub Projects board, split into two lanes
by owner. Cards tagged `owner:you` are mine — register an OAuth app, publish a
page, make a decision — and they're assigned to me, so GitHub's own "Assigned to
me" filter is my to-do list. Cards tagged `owner:claude` are the agent's: it
writes the code. The part that made it click: the agent runs the board itself —
opens each issue with an acceptance criterion, moves the card Todo → In Progress
→ Done with `gh`, and closing an issue means "done." I just watch the kanban and
drag my own cards.

Now I never type "what's next," and coming back after two days is one look, not a
re-read. We called it a Relay Board.

I could have used Trello and handed the agent a connection to it. But GitHub
Projects is free, sits right next to the code, issues and PRs, and my agent
drives it with the same `gh` it already runs — no extra connector to wire up.

## Reproduce this
Prerequisites: a GitHub repo under an org, the [`gh` CLI](https://cli.github.com)
authenticated, and the Projects scope granted once with `gh auth refresh -s project`.
Your agent will need from you: the project name and the task list (or a roadmap
doc it can draft the tasks from).
Steps:
1. Create the board and add work items:
   `gh project create --owner <org> --title "<name> roadmap"`, then
   `gh project item-add <num> --owner <org> --url <issue-url>` per issue.
2. Create two owner labels — `owner:you` (site action / registration / decision)
   and `owner:claude` (writes the code/docs) — plus optional `phase:*` labels.
3. Make each task one issue with a one-line **acceptance criterion** and a
   `- [ ]` checklist; reference dependencies inline as `#N`.
4. Assign every `owner:you` issue to the human
   (`gh issue edit <N> --add-assignee <handle>`) so GitHub's native
   "Assigned to me" filter becomes their queue — labels alone are invisible in
   the issue list.
5. Let the agent drive Status: read the Status field id and its option ids from
   `gh project field-list <num> --owner <org>`, map each issue number to its item
   id from `gh project item-list`, then move cards with
   `gh project item-edit --id <item> --project-id <pid> --field-id <status> --single-select-option-id <opt>`.
   Closing an issue counts as Done.
Verify: open the board in Board layout, Group by Status (or by Assignee for the
two lanes); `is:open assignee:@me` shows your queue; when the agent moves a card
and closes its issue, it lands in the Done column — the board, not the chat, is
now the shared state you both read.