Pulls a Teams transcript through WorkIQ MCP, or uses fixtures when an M365 tenant is not available.
Projects
Flagship agentic delivery system
prd-to-prod
A governed delivery pipeline built on GitHub Agentic Workflows. A brief becomes issues, PRs, reviews, deploys, and repair loops, with a human-owned policy deciding where agents stop.
- PRD
A product brief lands as an issue, with scope, stack, and constraints written in public.
- Plan
Architecture Planner and PRD Decomposer turn the brief into ordered, reviewable work.
- Build
Repo Assist implements feature issues through pull requests instead of hidden code drops.
- Review
Review agents check the PR, surface blockers, and keep a separate identity from the builder.
- Ship
Merge and deploy steps stay deterministic, with agents operating inside explicit policy.
- Repair
CI failure drills route defects back through the same issue to PR loop.
Policy Human approval stays explicit. Agent work stays inspectable.
198 merged PRs in the public repo
5 archived autonomous build runs
34 gh-aw issues authored, 33 closed
~24h from Aurrin PRD to first deploy
Problem
Code generation was not the bottleneck. Delivery was.
The experiment started from a sharper question than "can an agent write code?" The useful question was whether agent work could survive the delivery path: decomposition, architecture, tests, review, merge, deploy, failure recovery, and a record a human could audit later.
System
gh-aw supplied the runtime. prd-to-prod supplied the delivery operating model.
GitHub Agentic Workflows answered how to run agents inside GitHub Actions. prd-to-prod used that substrate to coordinate a multi-agent product lane, from a root PRD issue to production deployments and repair loops.
- GitHub Actions as the deterministic control plane
- gh-aw as the agent workflow runtime
- Autonomy policy for human-owned boundaries
- Issue, PR, review, and deploy traceability
- Separate agent identities for build, review, diagnostics, and status
- Self-healing paths for CI and deployment failures
Harness
Five layers between a model and merge authority.
The operating layer around the agents, from Designed for Humans. Each layer exists because a specific failure happened without it.
Variant
meeting-to-main was the input side of the machine.
prd-to-prod started with written specs. meeting-to-main asked what happens one step earlier: can a real meeting become a PRD, then a repo, then a deployed service without a human writing the application code?
Uses Claude to turn the transcript into a structured PRD, then validates shape and stack constraints.
Creates a fresh repo from the pipeline scaffold, provisions secrets, files the PRD issue, and comments /decompose.
Hands the implementation lane back to prd-to-prod, ending in pull requests, merge, and Vercel deploy.
The strongest proof was a working end-to-end run: meeting transcript to deployed API. The important boundary was just as useful: the first version handled greenfield work, not existing product repos, so the v2 consolidation folded it into prd-to-prod as an ingress mode with `extraction/` and `trigger/` paths.
Runs
Five archived runs, each generated from a PRD.
The public repo kept the evidence in tags and showcase manifests. Each run started with a spec, decomposed into issues, and moved through pull requests that could be inspected after the fact.
01 Code Snippet Manager Express + TypeScript 8 features, 7 PRs, zero human implementation code 02 Pipeline Observatory Next.js 14 10 features, 32 tests, live deployment 03 DevCard Next.js + Framer Motion 17 issues, 22 PRs, 6 themes, 29 tests 04 Ticket Deflection ASP.NET Core + Azure 52 issues, 37 PRs, 119 files changed, live Azure deployment 05 Compliance Scan ASP.NET Core + C# PIPEDA and FINTRAC scanner, 8 issues, 8 PRs
Upstream
The most useful contribution was finding where the platform broke.
Running prd-to-prod against real delivery work turned the pipeline into a stress test for gh-aw. I authored 34 gh-aw issues, 33 of them closed as of June 4, 2026, with fixes credited across multiple release notes. The contribution was diagnosis, reproduction, and system pressure.
Pilot
Aurrin Ventures made the boundary real.
The private pilot took a large PRD through the same loop: 12 core modules, 6 roles, 15+ entities, and a clean decomposition into 20 atomic issues. The first pipeline-built production deployment landed about 24 hours after PRD submission. Over the observed six-day window, the graph reached 133 closed issues, 80 merged PRs, and 15 production deployments.
It also showed where autonomy should stop: bootstrap setup, rerun state, deploy credentials, and client handoff still needed human control. That boundary became part of the product, not an embarrassment to hide.
Writing
The essays became the proof trail.
prd-to-prod was not just a repo. It became the spine for public writing about executable issues, human-readable autonomy, and open-source contribution when agents do the code but humans still own the judgment.
The New OSS The essay that turned the gh-aw work into a public argument about issue-first contribution. Designed for Humans The governance essay: autonomy policy, decision state, identity separation, and repair loops. The Agent Interface The data-backed follow-up on why issues became the interface for executable intent. GitHub Next X post The public signal that connected the writing back to the GitHub Next community.
Outcome
The artifact was a delivery lane with receipts.
prd-to-prod earned a place beside Sonora because it proves a different kind of shipping: not one app released by hand, but a repeatable system that turned specs into inspectable software and exposed the exact places where agentic delivery still needs policy, tools, and taste.
Open the public repo