OPC — One Person Company
One Claude Code skill that runs a 21-role pipeline with code-enforced quality gates, so a solo builder gets build, review, and verification coverage.
Per-dimension scores and reasoning
The README describes code-enforced guards (write nonce, atomic writes, plan SHA256 integrity, review independence, tick limits, oscillation detection), which is directionally sound. However, no permission manifest or least-privilege statement exists; `/opc pass` can force-pass a gate and `/opc loop` runs unattended for 10+ hours with a durable cron, yet there is no explicit confirmation flow or blast-radius documentation. Data flow (session writes under ~/.opc/sessions, extension hook execution) is only mentioned at README level with no sensitive-data policy. Dependency surface is small (no npm deps in core runtime, Node>=18), but the postinstall script silently copies files into ~/.claude/skills, and the README itself acknowledges npm now blocks install scripts by default. Deductions: no permission model, no confirmation mechanism, no data-flow/sensitive-data documentation, external effects and rollback asserted only in prose.
CI runs test/run-all.sh on Node 18/20; test files cover init-loop, complete-tick, review independence, JSON crash recovery, and backlog accumulation, and test-audit.sh exercises real git repos with fabricated sessions, so failure paths are tested. The README is self-consistent about quick vs build-verify tradeoffs and the brief node's limitation (test actual built code, not the brief's ideal). But failure-message quality has no direct evidence (tests only assert PASS/FAIL counts), and dependency availability rests on the engines field plus a 'no npm deps' claim, with no documented degradation for missing optional jq, memex, or the private opc-extensions. Deductions: failure_messages unevidenced; dependency availability asserted rather than verified.
The README enumerates five flow templates with usage conditions (quick limited to single-file, non-UI, no logic branches) and gives trigger examples (review/implement/loop/-i/explicit roles), so trigger precision is well described; capability boundaries are also stated (brief describes intended behavior, test-design must test actual code). Environment fit, however, covers only Claude Code + Node>=18; extension dirs, runbook dirs, and model routing are bound to the Claude Code ecosystem, with other hosts dismissed in one line about swapping model IDs. Deduction: environment_fit is thinly evidenced.
README structure is clear (bilingual, install, usage, guard table, flow table, roles, testing, requirements), LICENSE is full MIT text, and package.json carries version 0.11.0 plus a files whitelist, so information architecture and install notes are adequate. But CHANGELOG.md is only referenced, not shown, so version history is unverifiable; naming stability has no evidence (no API/CLI compatibility promise); examples point only to examples/runbooks and an extension starter with no FAQ; known limitations are scattered hints (quick constraints, brief caveat) rather than a consolidated section; maintenance responsibility rests on an author field and Discussions links with unverified publisher identity. Deductions: versioning_changelog, naming_stability, examples_and_faq, known_limitations, maintenance_responsibility all lack evidence.
Output usability is supported: mechanical gates (red=FAIL/yellow=ITERATE/green=PASS), automatic backlog.md accumulation of findings, structured eval files, and audit JSON output give concrete artifact shapes; the lookbook shows six real sites as effect evidence. Marginal value is hard to judge statically — overlap between 21 roles, 6 templates, and the extension system versus native Claude Code capability is unstated, and the six companion extensions live in a private repo, so the public repo alone is materially reduced. On cost, parallel multi-agent dispatch and 10+ hour unattended loops have no token/time quantification. Deductions: marginal_value and cost_benefit lack verifiable evidence.
Most strong README claims (10+ hours unattended, measurable first-pass build fidelity lift, 100+ test files, the four-layer zero-trust architecture) have no supporting evidence files or data and remain assertions; the test scripts are readable with concrete assertions but no run results are shown; lookbook links point to an external site that cannot be verified as pipeline-generated in a static review. Fact/inference separation is reasonable (README distinguishes code-enforced from prompt-level), but claim_traceability and cross_source_corroboration are weak: no benchmarks, no third-party reproduction, no versioned evidence chain. Deduction: core performance and quality claims are untraceable.
- `/opc pass` can force-pass quality gates and `/opc loop` runs unattended for 10+ hours with a durable cron; confirm blast radius and stop controls before granting this skill.
- The postinstall script writes into ~/.claude/skills automatically; npm blocks install scripts by default and the README suggests --allow-scripts, so review scripts/postinstall.mjs before installing.
- The six companion extensions (design-intelligence, dataviz-x, etc.) live in a private repo, so the public repository alone may not deliver the capability shown in the README.
- README claims such as '10+ hours unattended', 'measurably lifts first-pass build fidelity', and '100+ test files' lack verifiable evidence and should not drive adoption decisions.
- Publisher identity is not verified by the FollowAgents curated enterprise registry; maintenance responsibility and update path are unclear, and CHANGELOG.md is not present in the evidence.
What does this agent do, and when should you use it?
OPC (One Person Company) is a multi-agent orchestrator shipped as a Claude Code skill. It bundles 21 built-in roles — pm, designer, frontend, backend, security, tester, a11y, devil-advocate and more — and drives them through a digraph pipeline made of typed nodes: discussion, build, review, execute, and gate. The organizing rule is that the agent doing the work never evaluates it: build nodes produce commits, review nodes dispatch 2–5 independent role subagents in parallel, and gate nodes compute verdicts mechanically rather than by LLM opinion. The runtime is the Node-based opc-harness CLI, which resolves flow routing, synthesizes verdicts (any red = FAIL, any yellow = ITERATE, all green = PASS), routes models, and owns state writes. Guardrails such as a write nonce, a plan SHA256 hash, mandatory git commits, screenshot artifacts for UI units, tick limits, and oscillation detection live in code, not in prompts. Installation copies the skill to ~/.claude/skills/opc/, and everything is driven from /opc slash commands inside Claude Code.
A run starts with /opc followed by a natural-language request. OPC infers the task, selects one of five flow templates (quick, review, build-verify, full-stack, pre-release), and enters at the appropriate node. In build-verify, the entry brief node emits a structured build brief — resolved design tokens, file plan, component inventory, constraints — that the build node then implements and commits. code-review dispatches role agents in parallel, test-design and test-execute generate and run tests, and the gate node calls opc-harness synthesize for PASS / ITERATE / FAIL. An ITERATE verdict routes to hotfix and back into test-execute. Loops are capped at 3 per edge, 5 re-entries per node, and 20–30 total steps. The loop mode (/opc loop build features F1–F4 from PLAN.md) first runs opc-harness runbook match against --dir, OPC_RUNBOOKS_DIR, and ~/.opc/runbooks/ to find a matching recipe; on a miss it decomposes the task into atomic units (spec, implement, review, fix, e2e), establishes definitions of done, schedules a process-restart-durable cron every 10 minutes, runs one unit per tick, and terminates on plan completion, tick limit, or a 24-hour wall-clock deadline. Extensions placed in ~/.claude/skills/opc-extension/<name>/ provide ext.json capability declarations plus a hook.mjs exporting promptAppend, verdictAppend, executeRun, or artifactEmit, each sandboxed with per-extension timeouts and circuit breakers. Model dispatch is resolved before every Agent call by opc-harness model-route across economy/standard/premium tiers, defaulting to haiku/sonnet/inherit.
- A solo developer who wants a finished, presentable artifact from one sentence: run /opc build a SaaS analytics dashboard and the build-verify flow supplies the brief, independent review, and test stages.
- Reviewing unfamiliar or risky code: /opc review the auth changes fans out to security, backend, a11y, and devil-advocate roles in parallel, then the gate issues a mechanical verdict.
- Kicking off a long feature batch from an existing PLAN.md overnight: /opc loop build features F1-F4 from PLAN.md decomposes units, schedules durable cron, and advances unit by unit without intervention.
- Making a small edit without sacrificing the quality gate: the quick template (build → review → gate) covers single-file, non-UI changes with no logic branches.
- Running pre-release acceptance: /opc verify before release executes acceptance, audit, and e2e gates before anything ships.
- A team that wants its own checks inside the pipeline: author an opc-extension with hook.mjs to append prompts, extend verdicts, or emit artifacts.
What are this agent's strengths and limitations?
- Verdicts are mechanical: opc-harness synthesize applies fixed rules (any red = FAIL, any yellow = ITERATE, all green = PASS), so no LLM decides whether a finding is 'important enough'.
- Autonomous loop guardrails are code-enforced rather than prompt-level — write nonce, plan SHA256 verification, mandatory HEAD change, screenshot artifacts for UI units, concurrent tick mutex, and JSON crash recovery.
- The extension surface needs no fork or rebuild: ext.json plus a hook.mjs exporting promptAppend / verdictAppend / executeRun / artifactEmit, with per-extension timeouts and circuit breakers containing broken extensions.
- Tiered model dispatch prevents accidental premium fan-out: economy/standard/premium map to haiku/sonnet/inherit, with inherit and opus requiring explicit approval and CLAUDE_CODE_SUBAGENT_MODEL overrides detected and reported.
- Substantial test coverage: 100+ test files spanning init-loop, complete-tick, review independence, JSON crash recovery, scope registry, release packaging, and orchestrator-level E2E flows.
- Runtime is tied to Claude Code: installation, slash commands, and subagent-model override detection are all written for that host, so other runtimes require adaptation work.
- Unattended loops have hard ceilings: maxTotalTicks (units×3) plus a 24-hour wall-clock deadline can stop a long-running plan before it finishes.
- The quick template is deliberately narrow — single-file, non-UI, no logic branches — so any change with branching or multiple files must use the heavier build-verify flow.
- The companion opc-extensions repo (design-intelligence, dataviz-x, quality-reality and three others) is private, so its capabilities are not reusable without it.
- npm installs may silently skip the skill copy because install scripts are blocked by default, requiring --allow-scripts or a follow-up
opc install. - Cross-session memory depends on the optional external memex project; without it, context is confined to a single session.
How do you install or deploy this agent?
Requirements: Claude Code (CLI, desktop app, or IDE extension) and Node.js >= 18. The core runtime has no npm dependencies, no MCP server, and no build step. Install with npm install -g @touchskyer/opc; skill files are copied automatically to ~/.claude/skills/opc/. Recent npm versions block install scripts by default — if opc --version prints but ~/.claude/skills/opc/SKILL.md is missing, rerun with npm install -g --allow-scripts=@touchskyer/opc or run opc install once afterwards. Manual install without npm: git clone https://github.com/iamtouchskyer/opc.git then cp -r opc ~/.claude/skills/opc. Optionally run opc install-hooks (always installs the Node-based auto-flow guard; installing jq additionally enables context-compaction hooks), and optionally npm install -g @touchskyer/memex for cross-session memory.
How do you use this agent?
After installing, drive everything from /opc slash commands inside Claude Code: /opc review the auth changes for parallel review, /opc implement user authentication with email/password for build + independent review + gate, /opc loop build features F1-F4 from PLAN.md for unattended loop execution, /opc -i redesign the onboarding flow for interactive clarifying questions first, and /opc security devil-advocate to name roles explicitly. Flow control: /opc skip, /opc pass (force-pass the gate), /opc stop (terminate and preserve state), /opc goto build. Custom roles are added simply by dropping a .md file with tags, Identity, Expertise, and When to Include sections into roles/ — available immediately with no configuration. To run on other hosts, replace the economy/standard/premium values in agentRouting.models with your own model IDs.