How I Built a Software Factory for Personal Work
November 2, 2026
Last year, I wrote about how coding agents had changed my work. In that post, I guessed that we would soon provide an input, expect an output, and think less about the code. I also wondered if the infrastructure around these things could be challenging and fun in its own way. As working with agents and the primitives around agentic development matured (sort of 🤷), handing off more of the work to agents started to make much more sense. I have a monorepo, which this blog is also part of, that I use as a playground for trying all kinds of emerging agentic development practices. So I wanted to push this workflow as far as I could.
The result is a self-running software development lifecycle: a clear path from an idea to a reviewed change. I settle the scope, it lands in a GitHub issue, and I add one label. A GitHub Actions job on my Mac Studio then starts a coding agent that implements, reviews, and publishes the work. I still decide what to build, merge the changes, and check the result. The factory handles everything between those decisions.
Keeping everything in one monorepo gives the agents a simple world to work in. One checkout holds all the context they need: my apps, shared packages, documentation, repository rules in AGENTS.md, and the skills. Every project uses the same Bun and TypeScript setup and the same commands for checks. A change that touches several projects is still one issue and one pull request.
This changes where I spend my attention. I still give code changes a light review, but I want to rely more on output signals. Those are what the tests say, what reaches main, and how the system behaves. If it works, it works. I'm still working toward that, and I don't expect to get every part right, but the factory is one of the first steps.
The Work Starts Before the Factory
The backbone of my development flow comes from Matt Pocock's agent skills. A skill is a short instruction file that tells an agent how to do one kind of work. For a substantial feature, I start with grill-me, or with grill-with-docs when the decisions should also update my glossary and decision records. The agent questions the idea, one round of decisions at a time, until we share the same understanding. I think this is the part that matters most.
to-spec then writes those decisions into a specification. to-tickets turns the specification into delivery slices, each with its own acceptance criteria and dependencies. For work too large for one session, wayfinder first maps the open decisions as tickets. I use Claude Opus 5.5 on medium effort for all of this planning work. I don't read the finished specs and tickets, because the grilling session already shows me what the outcome will be.
Every piece of work starts as a GitHub issue. For a larger feature, that issue is the specification. It says what problem I'm solving, the intended behavior, the scope and constraints, and how I will know the work is complete. The agent that builds it starts with no memory of the original conversation, so the issue must hold the accepted answer. A small fix needs only one issue and one pull request.
In a larger feature, each child ticket has its own scope, acceptance criteria, expected tests, and native GitHub links to any ticket that blocks it. Let's say I want to change the blog in three slices: shared styling, article layout, and a header fix. The article work depends on the styling ticket. The header fix is independent, so the agent can build it at the same time as the styling.
I install third-party skills with the skills CLI and keep copies in the monorepo. skills-lock.json records each imported skill, and I review the import diff before each update. On top of them sit a few small skills of my own, and I explain the main ones where they appear below. I keep the whole set lean. Each skill is short and points to the repository's documents, and I remove what I no longer need.
Moving Up the Agentic Ladder
I automate a process only after I have run it by hand and watched how agents behave in it. When the results are predictable and I trust them, I let the process run without me. For me, each automated process is one step up the agentic ladder.
Delivery is the clearest example. do-the-thing, my own delivery skill, takes accepted scope to reviewed pull requests and a handoff. I first ran it in local Codex sessions and watched each step. I still run small local tasks that way, with another skill of mine, track-task, keeping the issue on the board.
After many of those sessions, I trusted the flow enough to automate it. The same skill now starts from a GitHub label and runs while I do something else. I review its handoff at the end. Planning, my own code review, and QA are on lower steps today, and they are the next ones I want to automate. I think the steps after them will come fast.
GitHub Holds the Project State
I use GitHub Issues and Projects as the project management tool. Each app in the monorepo has its own Project board, and shared monorepo work has one more. One look at the right board shows me where each piece stands.
The spec holds the decisions and final acceptance. Child issues hold the slices that can be implemented and reviewed separately. Native parent and blocker links show how the pieces fit together. Pull requests show the actual code and review evidence.
GitHub is the single source of truth for the factory. It's a practical choice. The issues, labels, pull requests, and checks already live there, and every agent can read them.
Project statuses follow the work. A local task moves to In Progress when the agent starts. A label-started run keeps its issue in Todo until the first pull request opens, and then the issue moves to In Review. Each pull request carries an exact Agent Run: #<issue> line that links it to its issue. Skips, questions, and handoffs appear as comments on the issue.
A green pull request is still In Review. An issue is done only when its own deliverable passes acceptance. A merged child can be done while its parent still needs product or runtime evidence.
One Label Starts One Run
When the scope is settled, I put the issue in Todo and add agent:run. For background work, that label is the only authorization. For ticketed work, I add it to the spec, and one run delivers the full ticket graph.
The label triggers a GitHub Actions workflow, which also sweeps labelled issues every hour. The jobs run on several self-hosted runners on my Mac Studio, and I add more as the work grows. Each runner uses the agent CLIs I already log in to, so runs use my existing subscriptions. Approved work continues without an open terminal session.
A small Bun launcher reads the issue, its Project status, and its open pull requests. Then it decides:
- The label must come from one of my accounts.
- A child ticket is skipped with a comment that points to its spec.
- An issue in Todo starts a new run.
- An issue in In Review with open Agent Run pull requests resumes.
- An issue with an open blocker keeps its label and waits.
- Any other issue is skipped with a comment.
GitHub holds the state, and GitHub Actions handles scheduling, concurrency, and cancellation. The launcher connects the two, prepares the issue's own copy of the repository, and starts do-the-thing. The rest of the factory lives in that skill.
Agents work on GitHub through a dedicated bot account. It commits, opens pull requests, and comments on issues. I stay the reviewer and the only person who merges. Because the bot pushes with its own login, CI runs on its pull requests, and its changes are easy to tell apart from mine.
Each spec runs as one job on one runner. Inside that job, implement-spec gives independent tickets their own subagents and worktrees, so they are built at the same time. Dependent tickets wait for the tickets that block them. Separate issues run in parallel on separate runners. Spreading one spec over several runners would add capacity, but I think coordinating that safely is a problem of its own.
What Happens in One Run
The agent reads the full issue and its comments first. If the outcome or a required decision is unclear, it posts questions on the issue, removes the label, and stops. I answer on the issue and add the label again.
By default, implementation runs on GPT-6.1 Sol at high effort through Codex. A label such as agent:claude selects another agent. I have several AI subscriptions for personal use, and I try to use all of them. The agent runs with full permission bypass, so a background run never waits for an interactive prompt.
For a single task, the agent follows implement, Matt's skill for building one accepted change. It uses tdd for red-green-refactor cycles where test-first work is feasible. For a spec, it follows implement-spec across the full ticket graph. Dependent tickets become stacked pull requests with GitHub's gh-stack skill, built in one checkout. Independent tickets get their own pull requests.
Review uses separate, read-only agents. First, code-review checks the change against my coding standards and against the spec, in two parallel reviews. Then every other model family on my roster reviews it once, through my other subscriptions. A Codex change gets Claude and Grok reviews, and a Claude change gets Codex and Grok reviews.
The agent checks each finding against the current source. It fixes real defects and records why the other findings need no change. Open findings go into the pull request body as decisions for me. If a reviewer is unavailable, the run records the exact error and continues with the evidence it has.
The agent writes each pull request body with Matt's pr skill. That skill asks for a short summary diagram, before-and-after evidence, and the blast radius of the merge. The agent publishes the pull requests ready for review, moves the issue to In Review, and requests my review. The same job continues with PR Steward.
All of this is one Agent Run: one job, with one agent that coordinates its subagents and reviewers. I keep thinking about splitting the steps across runners, so each step gets its own role and a clean context. I'm not sure yet that it's worth the extra coordination.
PR Steward Watches the Pull Request
pr-steward is my skill for the time after a pull request opens. It observes each pull request every five minutes and reads the head, base, checks, mergeability, reviews, and threads. It fixes verified CI failures and review defects on the same branch. A finding that needs my decision comes back to me. Every finding needs an answer before its thread closes: a fix, a reason why no change is needed, or my decision.
Codex Review and Codex Security also run on GitHub when a pull request opens. They give each change one more fresh review. PR Steward waits for the reviews that are queued and treats their findings like any other.
An observation is clean when the checks pass, the branch is mergeable, and every finding has an answer. The quiet gate passes after three clean observations in a row. A new commit, check result, review, or decision resets the count. A branch that is only behind main keeps its count, so the agent doesn't rebase and restart CI without a reason.
After the quiet gate passes, the agent writes one handoff comment on the issue. The comment lists the pull requests, exact heads and bases, checks, review decisions, and observation times. It names the acceptance work that remains. It ends with a short retro from Matt's retro skill, which suggests improvements to the agent's environment. Then the agent removes agent:run and the job ends.
I review the pull requests and squash-merge them myself. The agent never merges, enables auto-merge, or adds agent:run. If I leave feedback on a pull request, I add the label again. The issue is In Review with an Agent Run pull request, so the launcher resumes. PR Steward addresses the feedback, waits for the quiet gate again, and writes a new handoff.
Recovery Starts From What Still Exists
A long run can stop before it finishes. A runner can restart, a job can fail, or I can cancel it in GitHub Actions. A stopped run keeps its label and Project status, so the issue still shows unfinished work.
Each issue has its own permanent copy of the repository on the Mac Studio. The agent's branches and commits live there, including the ones it hasn't pushed yet. A cancelled job or a replaced runner leaves that work in place.
To continue, I rerun the job, or the hourly sweep finds the labelled issue. The agent looks at the existing branches, commits, and pull requests first. Then it continues from where the last run stopped.
The Factory Can Outgrow One Machine
The runners are ordinary self-hosted GitHub Actions runners, so the factory can move or scale beyond my Mac Studio. When I need more compute, I can add more machines to the local stack. Linux machines would work too, with the agent CLIs installed and logged in. The launcher and the skills would stay almost the same, and the workflow would need new runner labels. The catch is the permanent copy of each issue: it lives on one machine, so a resumed run must return there to see unpushed work.
Several cloud providers also offer runners that work with GitHub Actions. Their per-minute pricing may not make sense for agent runs, even for personal work. A run can take hours, and the runner spends most of that time waiting on the model and on PR Steward. A machine I already own costs nothing extra while it waits. Cloud runners would also need a safe way to hold my agent logins.
The Feature Ends With Acceptance
A handoff means the pull requests are stable. The feature still needs acceptance. During the run, the agent verifies its work against the acceptance criteria in the issue. Tests, checks, and reviews cover what it can verify itself. The handoff names what it couldn't verify, and I check those parts by hand.
Each written requirement ends up as passed, failed, blocked, or not tested, and the spec stays open until its deliverable passes. Today, planning, my own code review, and QA are where the factory needs me most.
What I Want to Improve Next
So, what comes next? These are the improvements I can see today:
- Full-spec QA by the agent: The agent should check the complete spec. My part is to give it a verification method for each requirement, so it can continue without me.
- Less human code review: In an ideal world, I would skip most code review. First, I want shorter pull request bodies and agent comments. The
prskill gives a good structure, but its output is still too verbose for me. After I watch that for a while, I may automate approval in increments, starting with a small blast radius. Changes to agent infrastructure, such as skills andAGENTS.md, still need my full review. - Data from the runs: Run data is scattered today, across GitHub Actions logs, each agent's session transcripts, and handoff comments. I want to turn it into analytics and observability data that I can understand and even benchmark. When I have that, the whole system will make much more sense.
- The shape of the flow: Automated QA may not need a separate flow. Maybe each step should get its own runner, with its own role and a clean context. Maybe not. I could also run
retroin a more automated way, so its findings become issues directly. An agent could grill those issues, and the sensible ones could go straight into the factory.
So, where does that leave me? I still review the pull requests, and I can stop or revise the work at any point. This setup is one snapshot of a moving target. Models, tools, and practices change every few weeks, and each change can move the next step within reach. I keep the factory lean, revisit it often, and expect its next version to look different.
Last year, I wondered if this kind of infrastructure could be challenging and fun. So far, I think it is. Let's see how long that lasts.