Eric walks through an open-sourced "software factory" — a set of Claude-style agent skills that pull issues from telemetry tools (Sentry, PostHog), turn them into GitHub tickets, and run them through a builder → QA → reviewer loop that mimics a real dev team. Each specialist agent chains curated skills: Ponytail for complexity reduction, Context7 for library docs, MapPoke for implementation, plus dedicated QA and review flows, with every agent comment logged on the GitHub issue. The setup is meant to be model- and harness-agnostic (Claude Code, Codex, etc.) and installable in about three steps.
- The pipeline is: telemetry (Sentry/PostHog) → a "supercollect" skill that scrapes issues on a schedule → GitHub project board tickets → "superboard" which runs specialist builder, QA, and review agents one ticket at a time.
- Failed QA sends the ticket back to the builder for revisions, and tickets needing human sign-off get moved to a blocked column rather than auto-shipped.
- Every agent's work and comments are written back to the GitHub issue along with the pull request, so a human or another agent can audit what happened.
- Before any code is written, the builder runs two prep skills: Ponytail, which uses a seven-rung ladder to ask whether the code should exist at all (reuse a util, a standard library, a native platform feature, an installed dependency, or a one-liner), and Context7, which reads the real documentation for the project's dependencies.
- The build step uses MapPoke skills — chosen over GSD, GSTA stack, and superpowers after reviewing them — with separate modes for implementing features, diagnosing bugs, and codebase redesign for refactors.
- The QA agent is built around testing-pyramid discipline: unit tests first, then integration and React component tests, and only then Playwright or Cypress end-to-end tests, so the right library is used for the right ticket.
- A separate UI refinement loop combines MapPoke with the Impeccable skill to diagnose, critique, restyle, add motion, and polish a page over several iterations to reduce "AI slop" design.
- Guardrails are enforced with hooks that block secrets from being committed, auto-generate a skills eval file, and keep README documentation from going stale.
Concrete explanation of the single biggest lever against agent code bloat, with the actual checklist the skill applies.
A lot of AI agents are writing code just duplicate after duplicates — a single file could be like a thousand or 100,000 lines. So what it does here is it has a ladder to see if this code here should be actually written at all.
A specific, defensible design decision that separates this QA agent from generic 'write some tests' prompts.
Chances are you probably are using Playwright for your testing. But that's the actual last step for testing itself. You want to actually test the bottom layer, like the fundamental unit testing layer, and eventually move up to integration testing or component testing.
A small feature once it's shipped can be used by millions or hundreds of millions of people, and one bug can cause a real cost in a production application.
Impeccable skill is simply a skill helping to design UI that are less AI slop.
Each ticket is actually being tracked inside of the GitHub issues... so any agent or human here can look at the actual issue log and see exactly what happened.