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.
- Source repo
- iamtouchskyer/opc
- Stars
- ★ 195
- Last updated
- 3d ago
- License
- MIT
- Primary language
- JavaScript
- FA score
- 48/100 · Major gaps
At a glance
- How it runs
- Works with
- Portable with changesClaude Code
- Cost
- Free software; you pay for model usage
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- 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.
- Not a fit if
- Teams not using Claude Code — install and slash commands assume that host
- Users wanting cross-session memory without also deploying memex
- Source review
- 48/100 · Major gaps
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.
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.
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 does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| OPC — One Person Company This agent | 48 · Major gaps | Agent plugin / skillFree + model costs | ★ 195 | 3d ago | JavaScript | Claude Code |
| OpenCode Swarm | 74 · Some gaps | Agent plugin / skillFree + model costs | ★ 518 | today | TypeScript | — |
| oh-my-agent | 48 · Major gaps | CLIFree + model costs | ★ 1.4k | 1d ago | TypeScript | Codex · Claude Code |
| Pi Dynamic Workflows | 88 · Good | Agent plugin / skillFree + model costs | ★ 590 | 9d ago | TypeScript | — |
How does FollowAgents rate this agent?
Why each dimension lost points
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.