From Notebook to Pipeline:
How I Run Every AI Project

A Board for One Person

The first version went up on April 27, built from a single 388-line prompt describing a dashboard for about six projects and 23 git repositories, the folders that hold each project's code and its history. Each project got a card with a task list, and each repository on it showed what needed my attention: changes not yet saved to that history, and saved work still waiting to be pushed up to GitHub. AI sessions commit work faster than I can review it, and by the end of a week I had lost track of which repositories held uncommitted work or a side branch, a separate copy of the code for trying something, that never merged back in, so in August the scan grew to cover branches too. Every signal on a card now carries an age, so a week-old stray branch looks different from this morning's edits.

The Ideas board went live on August 22, almost four months later, and that's the piece that replaced the notebook. An idea goes into the inbox in a few seconds with a keyboard shortcut on the Mac or from my phone, and from there it moves left to right across the columns until it ships or gets killed with a written reason. It's the board I wanted from JIRA, sized for one person and kept in a single file on my own machine instead of a subscription.

I wrote about this board once before, in the six-month Haunts.IO post, back when it was called My Day and had been running for three weeks. Every project I run goes through it now, and the public version is called My AI Workday.

Skills as Guardrails

Claude Code, the AI coding tool I use most, lets you write a skill, a plain text file of instructions that loads when you type a slash command such as /idea-plan. Each column on the board has a skill behind it, so moving an idea forward always runs the same steps in the same order, including the ones I would be tempted to skip on a busy day.

/idea captures an idea and stops there, with no planning and no code, because a quick note that turns into a build is how half-formed ideas end up in a codebase. /idea-brainstorm reads the project's code and writes a short brief with an effort rating and the conditions that would kill the idea, and /idea-plan writes a step-by-step plan into the project itself, where the next session can read it. The board won't mark an idea planned until that plan file exists, or built until a GitHub issue records what was done, so it can never show progress that didn't happen.

/idea-review hands the plan to a separate reviewer with one job, to find what the plan got wrong, and it can read the plan but not change it. In my setup that reviewer is a model from a different company, Codex from OpenAI or Gemini from Google, and the plugin falls back to a fresh Claude reviewer when neither is installed. The model that wrote a plan tends to miss the same things on a second read, the way a writer is a poor proofreader of their own draft, so every plan and every finished change in my workflow gets read by a model that didn't write it. The confirmed findings go back into the plan, and only then does the idea wait for me to approve it.

Approved ideas get built by /idea-execute, which splits the plan across subagents, separate AI sessions that each get one narrow piece of the work. Routine work like wording changes and tests goes to a cheaper, faster model, anything touching security or stored data goes to a stronger one, and a final reviewer reads the whole change against the plan before anything is pushed. The build runs while I'm doing something else, and it stops on its own at anything written down as off limits, such as a file the plan didn't name or a test suite that was already failing when the work started.

Every build ends with a pushed branch and a GitHub issue describing what changed, and it never deploys. Putting something in front of users stays my decision, made after I've read what the build did, and /idea-ship is the step where I record that I made it.

Where to Start

When I started coding with AI, every idea went straight from my head into a chat session, and the code that came back was only as good as the half-formed thought behind it. You don't need my app to stop doing that, because the habits underneath it work with a text file and any AI coding tool:

• Keep every idea in one place, and keep capturing separate from building.
• Have the AI write a plan into the project before it writes any code, so the next session starts from the plan instead of from memory.
• Ask a second model, ideally from a different company, to find what the plan got wrong before you build it.
• Leave deploying, the step that puts a change in front of users, to a person.

If you want the whole setup, the app and the Claude Code plugin are free and open source under the MIT license at github.com/michaeldpj/my-ai-workday. The README walks through installation and explains each column on the board and the skill behind it. The app runs on Apple silicon Macs, needs no account or server, and never writes to your repositories itself, and the skills run inside Claude Code, which still asks before it touches a file.