A harness for Claude Code.

A personal AI workbench that remembers your context, researches before building, ships a prototype, and reviews its own code. Work carries forward instead of starting over.

Idea → researched → shipped → remembered. In one session or many.

Elephants never forget. Neither does the harness.

$curl -fsSL https://raw.githubusercontent.com/Reef123/OpenVera/main/install.sh | bash
MIT · Claude Code · v1.20 · Read the docs →

Plain files in one folder. Nothing phones home after install. Prefer to look first? Clone the repo and read install.sh. What it won't do →

Persistent
Context survives between sessions.
Researched
It checks the space before it builds.
Honest
Plain files. Nothing phones home.
Safe
It stops before destructive commands.
What you get

Less starting over.

One skill wouldn’t be worth installing. The point is the arc: what you research feeds what you build, and what you learn shipping it shows up in the next run.

01
Remember
Context carries between sessions.
02
Research
Check the space before any code.
03
Build
Ship a working prototype.
04
Review
Something checks it before you trust it.
05
Improve
Lessons feed the next run.
Pick up where you left off.
The session opens with what moved and what’s next. No re-explaining your own codebase.
See the research before the code.
It checks what others already hit, then builds.
Ship something that works.
A feature counts as shipped only after it’s been verified working.
Catch bad plans early.
A reviewer reads the plan before you build it.
Stop repeating mistakes.
Fixes get written down once and reused.
Keep control of risky commands.
It asks first before anything irreversible.
§ 01 · The loop

Most loops automate. Few learn.

The difference is whether each cycle changes the loop itself. OpenVera’s loop has four organs, each backed by a hook or a script you can read.

It borrows the self-improvement loop from Karpathy and the agent-and-skills harness shape from OpenClaw. Neither idea is original here; wiring them into one runnable place is the work.

Build Sessions do real work and make real mistakes. Capture A session can't end until lessons are written back. forced Curate Only what recurs survives the prune. judged Promote Lessons become patterns, patterns become code. verified The next cycle starts smarter. CAPTURE, THEN CURATE
Fig. 1. The harness loop. Capture is forced; promotion is judged, then verified.

Capture is forced

  • Failures and corrections append a dated line to memory/lessons.md. A Stop hook blocks the session from closing until harness state is written back. Zero lessons is valid. The gate forces write-back, never wisdom.

Curation is judged

  • /curate runs weekly: one-offs age out, anything recurring three or more times gets flagged for promotion into patterns.md. You approve. The machine never edits your patterns file.

Promotion is verified

  • Every promotion lands in memory/promotions.tsv. Gone for fourteen days: validated. Recurs: marked failed and flagged for a hook, a doctor check, or a script gate. Prose that doesn’t work graduates into code that does.

The loop is measured

  • loop-report.py answers what cycle fifty knows that cycle one didn’t. It prints the numbers and keeps a trend file.
**Loop report 2026-06-10.** Since cycle 1 the loop has captured 31 lessons
(9 in the last 30 days), promoted 4 into patterns (3 validated, 1 failed),
and run 22 skill invocations in the last 30 days (86% pass).
A loop report headline (illustrative). Models get replaced. The harness gets smarter.
§ 02 · The shift

Sessions that build on the last.

Claude Code starts every session blank. OpenVera keeps state, decisions, patterns, and lessons in files on disk, so you stop re-explaining your own codebase.

Every session starts from zero.

Each run re-derives context, re-explains the codebase, and re-learns your conventions. Good decisions from yesterday are invisible today.

Every session builds on the last.

State, decisions, patterns, and lessons live in plain files you can read, grep, and edit. Prior research is citable. Session fifty starts where session one left off, and knows things session one didn’t. Every session opens with a cockpit: what moved, what’s next per thread, and what’s blocked on you.

WITHOUT OPENVERA S1 S2 S3 S4 S5 S6 S7 reset reset reset reset reset reset WITH OPENVERA S1 S2 S3 S4 S5 S6 S7 carry carry carry carry carry carry
Fig. 2. Session-to-session continuity. Isolated sessions reset; harness sessions accumulate state.
§ 03 · Before code

Research first. Pushback second.

The write-back loop is half the harness. The same skepticism runs upstream, before any code exists, so bad plans get cut before they get built.

It researches before it builds

/scout is a two-minute recon: Reddit and YouTube for what real people hit. /research goes deep: eight steps, multiple models so a single model’s blind spots have less room to hide, a source registry so claims are checkable. External findings stay untrusted: extract the technique, verify packages and env vars before you adopt.

Something that isn’t you pushes back

/panel reviews the plan for blind spots before /build. Validator and reviewer agents check the code as it’s built; a separate model scores the result. A per-feature ledger blocks any “done” claim until a validator confirms it. A scope guard cuts a prototype to one or two problems, because a finished prototype that solves one problem beats a spec for V3 that never ships.

§ 04 · Two build paths

Ship in a session, or plan across many.

Choose based on scope. Both paths feed the same memory, so lessons from a quick spike carry into a full production run.

/build new
One session, idea to working prototype.
For first versions and quick spikes. Scoping questions, scope guard, design tokens, then a build loop until it works in the browser.
/build full
Multi-session, plan to ship.
For production work. Deep research, gap analysis, PRD, tech spec, phased builds with tests, code review, QA, across persisted sessions. Don’t start here; start with /build new.
/ BUILD NEW idea working prototype single session / BUILD FULL plan design build review ship learn session 1 session 2 session 3 session 4 session 5
Fig. 3. Build journey. /build new collapses the arc; /build full persists it across runs.
§ 05 · Boot sequence

Three tiers of memory.

What’s loaded up front, what’s fetched on demand, and what stays out of context until searched. Boot renders the cockpit first.

Core EVERY SESSION · ~300 LINES cockpit.md · state.md · memory/patterns.md · relationships/user.md Recall ON DEMAND · LAZY LOAD ROADMAP.md · who-i-am/* · recent conversations Archival SEARCH ONLY · NEVER PRE-LOADED conversations/ · research papers · superseded plans
Fig. 4. Tiered context budget. Core is ambient; Recall is lazy; Archival is retrieval-only.
Core
Loaded every session
  • cockpit.md
  • state.md
  • memory/patterns.md
  • relationships/user.md
Recall
Loaded on demand
  • ROADMAP.md
  • who-i-am/voice.md
  • recent conversations
Archival
Search only, never pre-loaded
  • conversations/
  • research papers
  • superseded plans
§ 06 · Three primitives

Agents, Commands, Skills.

Three kinds of file compose the harness. You type a slash; the matching instructions load; the work fans out to agents when it helps.

PrimitiveWhatWhereExample
Agents Autonomous actors in isolated contexts. Fresh memory, scoped tools, can be spawned in parallel. .claude/agents/<name>.md Research subagent, code reviewer
Commands Prompt templates injected into the current context. Orchestrate workflows, trigger skills. .claude/commands/<name>.md /doc-sync, /commit
Skills Reusable knowledge packages, loaded lazily: one line in the system prompt until you invoke the slash command. .claude/skills/<name>/SKILL.md /research, /build, /improve
Orchestration: Command → Agent → Skill. You type the slash; the harness does the wiring.
§ 07 · Skills

Fourteen commands, one slash each.

Each skill is a knowledge package with a command surface. Most run free on your existing Claude Code subscription.

/start-vague
Bounded interview shapes a vague idea into a buildable spec. Mid-flow scout + ASCII wireframe.
/scout
Quick research: Reddit, YouTube, web. 2–3 min.
/research
Deep multi-model research. Source registry, paper output.
/consult
Simulates a panel of domain experts, gives one recommendation.
/frame
Design system, architecture diagrams, wireframes.
/wireframe-first
Sketches one screen in plain text and ratifies it before any code.
/panel
Pressure-test your plan before /build. Two reviewers scan for blind spots.
/advisor
Checks a decision against project artifacts, reports mismatches.
/code-review
Clean-context reviewer scans a path or diff for issues, returns tiered findings.
/build new
First version: idea to working app in one session. Resumable via state file.
/build full
Full process: plan, tech spec, build, review. Multi-session.
/improve
Runs a skill, scores the output, proposes instruction fixes, verifies no regressions.
/curate
Weekly memory cleanup: prunes stale, merges duplicates, verifies promotions.
/doc-sync
Saves the session: state file, conversation log, roadmap, lesson capture.
§ 08 · Boundaries

What it won’t do.

Enforced in .claude/settings.json and the hooks, not promised in prose. Audit them yourself.

Deny

  • sudo
  • rm -rf · rm -fr
  • .env files
  • .pem · .key · .ssh
  • .aws credentials

Ask first

  • git reset --hard
  • git push -f (force variants)
  • git clean -f
  • kill · pkill · killall
  • .secrets files

Won’t, by construction

  • Won’t push anywhere: nothing in the harness runs git push. Commits stay local until you push them yourself.
  • Won’t phone home: after install, no network calls happen on their own. Only the research scripts touch the network, and only when a skill you invoked calls them.
  • Won’t edit your patterns: patterns.md is hand-curated by rule. The machine lane is separate files.
  • Won’t keep a dossier on you: the optional user-memory lane records working preferences only. Health, family, employer, finances, location: never written. A doctor check enforces the rule.

Untrusted content

  • Script-fetched pages are wrapped in untrusted-content delimiters before the model reads them.
  • Extract techniques, not conclusions. Verify first, implement second.
  • External recommendations are input, not orders.
§ 09 · Install

One command.

$curl -fsSL https://raw.githubusercontent.com/Reef123/OpenVera/main/install.sh | bash
Prereqs: Claude Code CLI · Python 3.8+ · git

No pip step: OpenVera runs on Python’s standard library alone, so there’s nothing to fail to install. Rather inspect first? Clone the repo and run ./bootstrap.sh instead. API keys are optional: the harness, most skills, and the whole memory loop run on your existing Claude Code subscription. Keys add deep research, Reddit and YouTube depth, and an external scoring gate.

COPIED