10x

What makes someone 10x isn't the code they write.
It's the context they never lose.

You've worked with someone who's 10x. Not because they type faster. Because
they never re-derive context. They walk into a problem already knowing what was
tried, what was decided, what constraints exist, and where the bodies are
buried. They don't ask questions the project already answered. They don't reopen
decisions without new evidence. They scope before building. They verify before
declaring done. And they leave things in a state where the next person (or their
future self) can move just as fast.

Nobody is 10x on their first day. You get there by accumulating institutional
memory and never losing it.

Your AI agent starts every session at day one. No matter how good the model is,
it walks in cold. It doesn't know what was tried last month. It doesn't know
what was decided last quarter. It doesn't know which approach already failed and
why. You either re-explain all of that, or it makes the same mistakes again.

You might try solving this with a spec file, or a plan, or a custom prompt that
says "always think before coding." Maybe you commit those. They help with scope
and sequencing. But the reasoning behind the decisions? The three alternatives
you evaluated and why two won't work? The investigation that hit a dead end
with the rate limiting library? Those lived in the chat. The chat is gone.

Specs and plans are durable when you commit them. But engineering produces more
context than "what to build" and "in what order." It produces decisions with
rationale that shouldn't be reopened without cause. Research that maps out a
problem space, compares options, benchmarks alternatives, and reaches
conclusions you can cite months later. (It also knows it's temporal: the
conclusion that held in March may not hold in July, and the record says so.)
Evidence distinguishing what was verified from what the agent asserted.
Knowledge that compounds across the life of the project. Those have no
structured home in a spec-driven workflow.

10x gives each one a dedicated shape and place in your repo. Decisions get ADR
format. Behavioral contracts get their own spec files. Investigations become
research records with sources, methods, and conclusions you can link to from any
ticket that needs them. Observed facts go into evidence records, separate from
the agent's beliefs about what the facts mean.

Records reference each other by file path. A ticket cites the spec it
implements. Evidence names the ticket it supports. A decision points to the
research that informed it. When an agent picks up work weeks later, it doesn't
need a briefing; it follows file-path references outward and assembles its own
context. The result is an implicit graph that any agent can traverse from any
entry point. The same way a 10x engineer navigates institutional knowledge
without needing someone to walk them through it.

10x also carries twenty years of opinions about how engineering should go. The
protocol tells the agent to scope before building, to treat its own confidence
as a claim that requires evidence rather than a conclusion, and to verify before
closing. Subagent output is not trusted by default. A passing test is an
observation, not proof of correctness. The recording is what falls out of
working this way. The discipline is the point.

.10x/ grows with your project. The chat is disposable. The engineering isn't.

Protocol

What 10x changes

Even with good specs and plans committed, significant engineering context has no
place to go. Why was this approach chosen over alternatives? What was
investigated and abandoned? Was the result empirically verified, or did the
agent assert success? What risks remain after implementation? What should future
sessions know without being told?

Most tools try to fix this with better prompts. 10x fixes it with structure. It
makes the agent do the engineering and write it down, the same way a 10x
engineer writes things down because they've been burned by what happens when you
don't.

Vague requirements get interrogated before anyone writes code. Specs record what
the system should do independently of how the agent builds it, so you can
regenerate the implementation from the spec alone. Tickets give each piece of
work explicit scope and acceptance criteria. Subagents stay in their lane
because the lane is defined on paper.

A passing test suite is an observation. The agent's belief that the code is
correct is a separate thing. 10x keeps those apart. Work faces adversarial
review before a ticket closes. This is the epistemic stance running through the
whole protocol: a claim is not truth until evidence grounds it.

Research is not a write-once artifact. An investigation that mapped out rate
limiting options in March is still linkable from a ticket in June, but its
temporal flag tells you whether to trust the conclusions or re-investigate.
Knowledge records work differently: vocabulary, conventions, and heuristics
compound permanently. Both are first-class nodes in the graph, reachable from
any record that needs them.

Closing a ticket triggers a retrospective. Discoveries become knowledge records.
Repeated friction becomes a reusable skill. Follow-up tickets get opened for
debt that surfaced during execution. Session fifty is better informed than
session one because every session before it left something behind. The same
compounding that makes a human 10x over a career, happening at the speed of
agent sessions.

The shape

flowchart TB
  Goal["human goal"]
  Goal --> Outer["outer loop: shape intent into records"]
  Outer --> Tickets["tickets bridge to execution"]
  Tickets --> Inner["inner loop: subagent · evidence · review"]
  Inner -->|"done"| Knowledge["knowledge compounds"]
  Inner -->|"new scope"| Outer

Two loops joined by a bridge. The outer loop turns vague intent into concrete,
written records. The inner loop executes bounded tickets and produces evidence
that faces adversarial review. What gets learned feeds back in. This isn't a
checklist you execute top to bottom. Records accumulate and cross-reference. A
ticket opened today can draw on research from last month and a decision from
last quarter.

Simple edits don't need this overhead. The structure earns its keep when you're
dealing with architectural ambiguity, multi-session work, risky changes, or
anything where "what were we trying to do and why" matters more than "can the
model produce a patch."

Before and after

Without 10x: Monday morning. New session. "We decided on JWT with refresh
tokens last week, remember?" It doesn't. It can't. You dig through old chat
history looking for the reasoning. It's scattered across three conversations.
You re-explain. Fifteen minutes before anything productive happens. Every single
time.

With 10x: Monday morning. New session. The agent reads
.10x/decisions/2025-06-12-auth-strategy.md. It finds the JWT decision, the
reasons session cookies got rejected, and the open question about token rotation
intervals. It asks about the open question. Work starts immediately.

Record surfaces

Installing

Quickest path: copy the protocol into your AGENTS.md,
CLAUDE.md, or equivalent. Records generate in .10x/ as the agent works.

npx skills add z3z1ma/10x

Copy-paste

Copy PROTOCOL.md into the file your agent reads at startup:

It's a Markdown file. No dependencies, no runtime. Works in any harness that
reads an instruction file.

Skills ecosystem

npx skills add z3z1ma/10x

Vercel skills CLI. Supports OpenCode, Claude Code, Codex, Cursor, Gemini CLI,
GitHub Copilot, Windsurf, Roo Code, and others.

# Install globally
npx skills add z3z1ma/10x -g

# Target specific agents
npx skills add z3z1ma/10x -a claude-code -a opencode

# Non-interactive
npx skills add z3z1ma/10x -g -a claude-code -y

First-class harness support

Native plugin manifests for marketplace installation:

When to use it

10x is worth the overhead when context needs to outlast a session. Architectural
decisions that need to survive handoffs. Bug investigations where reproduction
steps matter. Multi-session work that decomposes into tickets. Anything where
"it looks right" is not sufficient evidence of correctness.

For one-shot changes where the intent is obvious: skip it. Use git.

10x Lab

Companion app for visualizing .10x/. Shaping sessions, ticket status, live
execution observation. Reads and writes the same Markdown records the protocol
defines.

See 10x-lab/ for details.

Repository layout

.
├── PROTOCOL.md              : Core protocol (copy into your instruction file)
├── skills/10x/SKILL.md     : Same protocol as an installable skill
├── .claude-plugin/          : Claude Code marketplace manifest
├── .cursor-plugin/          : Cursor marketplace manifest
├── .agents/plugins/         : Codex and OpenCode marketplace manifest
├── gemini-extension.json    : Gemini CLI extension manifest
├── 10x-lab/             : Companion visual application
└── .10x/                   : Dogfood records tracking this repo

For agents

If you're an AI agent reading this to install 10x:

1. Copy PROTOCOL.md into the project's instruction file (AGENTS.md,
   CLAUDE.md, or equivalent). Preferred method.
2. Or: npx skills add z3z1ma/10x for skills directory installation.
3. Self-contained once loaded. Read .10x/ if it exists. If not, trigger the
   outer loop when a request carries ambiguity worth recording.

Why "10x"?

Nobody becomes 10x by typing faster. They get there by never losing what they
learned on the last project. By scoping before building. By not reopening
decisions that were already settled for good reasons. By verifying instead of
assuming. By leaving the codebase easier to reason about than they found it.

Those practices are what this protocol externalizes. The agent that follows them
accumulates institutional memory the way a seasoned engineer does, except it
compounds at the speed of sessions instead of years.