A delivery pipeline you run per client.
Agencies and consultancies live or die on repeatable delivery and clean handoffs. opchain gives every client project the same idea → spec → design → build → ship pipeline, with the work checkpointed and auditable. The process is the same whether it's the first engagement or the fortieth — and it doesn't live in one senior dev's head.
Per-client checkpoint isolation
Each client project gets its own .checkpoints/ tracked in
git alongside its code. State — current phase, open blockers, decisions,
next actions — travels with the repo, not the person.
oc-orchestrator
(/oc-ops) reads a multi-project registry that spans every
client engagement on the machine, so
"where did we leave off on client X" is one command, not a
Slack archaeology session.
.checkpoints/ per client repo — no cross-contamination between engagements./oc-ops rolls up status across all projects into one view: which client is in which phase, what's blocked, what's next.The same pipeline, every engagement
The same skills run for every client, in the same order. Consistency across a team — not one senior dev's habits, not whatever the junior on the account remembered to do this time.
-
/oc-discoverPin down scope, users, and success criteria with the client before a line of code.
oc-app-architect -
/oc-specProduce the master spec doc — the contract everyone builds against.
oc-app-architect -
/oc-designArchitecture and UI decisions, captured as a design doc rather than a senior dev's memory.
oc-ux-engineer -
/oc-buildGenerator writes, Evaluator critiques against the spec, work kicks back until it passes.
oc-app-architect -
/oc-auditCode-quality gate with a graded audit report attached to the deliverable.
oc-code-auditor -
/oc-securityThreat model + OWASP + infra-hardening gate before anything ships to the client.
oc-security-auditor -
/oc-deployStaged rollout, health checks, and a monitoring runbook handed over with the keys.
oc-deploy-ops
The /oc-build phase runs a Generator/Evaluator QA loop, and
/oc-audit + /oc-security are hard gates —
oc-deploy-ops won't ship
to the client until both pass (or the override is recorded).
Deliverables, not just code
Clients pay for outcomes they can hold. opchain produces the supporting artifacts as a byproduct of the pipeline — they're generated from the work, so they don't drift from what actually shipped.
Scope, users, requirements, and acceptance criteria — the thing you got the client to sign off on.
fromoc-app-architect Stack choices, component structure, and the design decisions behind them, written down.
fromoc-ux-engineer A graded pass over the codebase — findings, severities, and what was fixed. Defensible at handover.
fromoc-code-auditor How it ships, how it's watched, and how to roll back — so the client's team isn't flying blind.
fromoc-deploy-ops Clean handoff
Because state lives in checkpoints and spec docs — not one person's head — a project can move between team members, or to the client's own team, without context loss. The next person reads the spec, the architecture doc, and the latest checkpoint, and they're current. No "let me find the one engineer who knows how this works."
Inheriting a codebase with no docs — a legacy client app, or work from
another shop? oc-reverse-spec
(/oc-rev-spec) backfills specs from the existing code, so
you start the engagement with the same artifacts a fresh opchain build
would have produced.
Run your next engagement on it
Install once, then run the same pipeline for every client. Tune the skill set to your stack with the pipeline builder.