Teaching Every Harness the Same Skills

This essay describes how I adopted Lauren Tan’s pstack skill collection into my own agent setup between late October and early November 2026. Every install was verified byte-for-byte and the parallel worker contract was exercised end to end before rollout. It is about what I run, not a survey of what is possible.

In September I came across Lauren Tan’s pstack: a collection of engineering skills a coding agent can load and follow — restate the problem before acting, recall context before starting, spawn competing designs and judge them, prove the work by running it. The ideas were not new. What was new was the form: small markdown contracts that live on disk, that any harness can read, and that survive the next model upgrade.

That distinction matters more than it sounds. A habit lives in a model version. A skill lives on disk. When the model changes next quarter, the skill survives. When I find a better way to run a design review, I edit one file and every agent that loads it inherits the improvement.

So I adopted it the way I adopt anything I intend to keep: not by admiring it, but by wiring it into everything I run. This essay is about how that went.

Before any of this, I already lived on a handful of personal skills of my own — the ones I type by name without thinking. Two of them came first and do the most work:

remember and recall are my two memory verbs. Remember saves a fact, decision, or correction into the right brain — personal for my own work and consulting, company for the products I support — with provenance attached. Recall is the read side: it picks the right brain, retrieves by entity, date, or question, and hands back a sourced answer. Every durable thing I know went through remember; every session that avoids re-explaining my life went through recall.

The other two I added during this program, and they turned out to be the glue for everything else:

readback restates what it understood from my dictated, half-formed request as a structured card — my goal in its own words, the numbered asks, the assumptions it made without asking — and stops. I confirm with one word or correct one item. And recommend turns any open decision into options with one recommendation marked, so I answer with a letter instead of typing prose. These four — remember, recall, readback, recommend — are the verbs I use most by an order of magnitude.

The adoption program did not replace them. It gave them a fleet to command.

The first surprise was how many surfaces the word “installed” covers. I run several harnesses — OMP, Claude Code in a few configurations, Codex, a Devin CLI — across a MacBook and a Mac Mini. Each has its own skills directory. A skill is not installed until it exists, byte-identical, in every root that should serve it. My first rollout missed the Mac Mini entirely. My second missed reference files: the skill body loaded fine while the prompt templates it needed silently did not exist.

Both failures taught the same lesson, which I now consider the core engineering rule of skills: a skill is a distribution problem, not a writing problem. The markdown is the easy part. The hard part is the installer, the checksums, the idempotent re-runs, the backups taken before replacement, and the verification pass that compares every copy against the source of truth and refuses to trust an unverified claim.

My installer now copies the body plus every asset directory, replaces them cleanly on re-run, skips anything marked retired, and takes a dated backup before it overwrites. It is forty-odd lines of shell. It has caught more mistakes than any review.

Eighteen skills now load identically in every harness I run, on both machines. They fall into four layers — memory verbs, request handling, engineering method, and orchestration — and the arrows show how they hand work to each other during a real session.

I did not copy pstack. I adopted it the way you adopt a dependency: keeping what works, changing what does not fit my setup, and writing the differences down. Six changes are load-bearing.

Everything else is upstream verbatim, pinned to a dated commit. When upstream improves a skill, I diff my copy against the new version, re-apply my small deltas, and roll it out in one command. Divergence is budgeted, recorded, and cheap to audit.

A skill that never fires is a document. The skills are explicit-invocation: nothing auto-runs. That is deliberate — I do not want an agent deciding on its own to spawn six parallel workers — but it created a dependency on me remembering which skill fits which moment, across every harness, at the speed of conversation.

The fix was not a bigger menu. It was wiring the invocation into the four verbs I already use daily. Readback’s card now has a section that names the installed skills matching each stated intent. Recommend’s contract already requires picking the right tool for a decision. Together they form a loop: I talk, the restatement surfaces the matching skills, I confirm with a letter, the work runs.

The pattern generalizes: don’t build a selector, build the habit loop. A selector that auto-executes removes the human gate exactly where judgement matters most. A suggestion line in a card I already read keeps the gate and adds the recall. The cost is one confirmation word; the benefit is that I never have to memorize an inventory.

• Skills are a distribution problem. Budget for the installer, the verification, and the backups before you write the first body. The writing is the small half.
• Byte-identical or it isn’t installed. “Roughly the same files in most directories” is how reference templates go missing. One checksum across every root, or it did not happen.
• Deleting is part of adopting. Nine directories replaced by one indexed bundle; a router retired the day its coverage map was complete. A skill list you cannot read is a skill list you will not use.
• Write your differences down. Six deltas from upstream, each recorded with a reason. The diffs are the documentation of how the method was adapted to a different life.
• Wire invocation into habits, not menus. The verbs that already run daily — remember, recall, readback, recommend — carry the rest of the roster.
• Prove the contract, then ship the proof. The alias-model bug was found in twenty-four seconds because the contract was exercised before rollout, not after.

Every harness I run now shares one skill roster, one installer, one source of truth, and one registry. A new session on either machine loads the same contracts: remember and recall for memory, readback and recommend for every request, the method layer for doubt, orchestration for material work. When I adopt the next skill, it is a directory copy and an installer run — minutes, not an evening.

But the real shift is smaller and more personal. The skills I rely on are no longer scattered across tool configs in my head. They are files I can read, checksums I can verify, a registry I can search, and a write protocol that refuses to let me be casually wrong. The method stopped being something one model happens to do well and became something my infrastructure does by default.

That is what I mean by teaching every harness the same skills. Not the same model, not the same context window — those stay different, and should. The same method. The same proof. The same memory of why.

• The Last Project You Build Alone — why the memory layer is custom, harness-independent, and never finished.
• Two Brains, One Operator — the personal and company split behind the routing in this essay.
• The Devin Issue Pilot — the same verification discipline applied to an agent teammate.
• Local Models & Harnesses — reviews of the runtimes this roster runs on.