{"id":51090147,"url":"https://github.com/z3z1ma/10x","last_synced_at":"2026-06-24T01:01:47.488Z","repository":{"id":335910026,"uuid":"1146905327","full_name":"z3z1ma/10x","owner":"z3z1ma","description":"The missing middle between prompt and patch: a Markdown-native protocol that turns AI coding sessions into durable work products agents can continue, audit, and trust","archived":false,"fork":false,"pushed_at":"2026-06-20T01:02:49.000Z","size":24740,"stargazers_count":17,"open_issues_count":4,"forks_count":1,"subscribers_count":1,"default_branch":"main","last_synced_at":"2026-06-20T01:08:28.690Z","etag":null,"topics":["claude","claude-code","codex","codex-cli","cursor","gemini-cli-extension","kilo-code","opencode","pi","skills"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/z3z1ma.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":"AGENTS.md","dco":null,"cla":null}},"created_at":"2026-01-31T21:45:23.000Z","updated_at":"2026-06-20T01:02:53.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/z3z1ma/10x","commit_stats":null,"previous_names":["z3z1ma/agent-loom","z3z1ma/pliny","z3z1ma/10x"],"tags_count":18,"template":false,"template_full_name":null,"purl":"pkg:github/z3z1ma/10x","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/z3z1ma%2F10x","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/z3z1ma%2F10x/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/z3z1ma%2F10x/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/z3z1ma%2F10x/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/z3z1ma","download_url":"https://codeload.github.com/z3z1ma/10x/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/z3z1ma%2F10x/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34712578,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-23T02:00:07.161Z","response_time":65,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["claude","claude-code","codex","codex-cli","cursor","gemini-cli-extension","kilo-code","opencode","pi","skills"],"created_at":"2026-06-24T01:01:46.937Z","updated_at":"2026-06-24T01:01:47.462Z","avatar_url":"https://github.com/z3z1ma.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003cp align=\"center\"\u003e\n  \u003cimg src=\"assets/banner.png\" alt=\"10x banner\"\u003e\n\u003c/p\u003e\n\n\u003ch1 align=\"center\"\u003e10x\u003c/h1\u003e\n\n\u003cp align=\"center\"\u003e\n  \u003cem\u003eThe engineering discipline that makes a developer 10x — encoded as agent instructions.\u003c/em\u003e\n\u003c/p\u003e\n\n\u003cp align=\"center\"\u003e\n  \u003cimg src=\"https://img.shields.io/github/stars/z3z1ma/10x?style=flat-square\u0026color=111111\u0026label=stars\" alt=\"Stars\"\u003e\n  \u003cimg src=\"https://img.shields.io/github/v/release/z3z1ma/10x?style=flat-square\u0026color=111111\u0026label=release\" alt=\"Release\"\u003e\n  \u003cimg src=\"https://img.shields.io/badge/works%20with-70+%20agents-111111?style=flat-square\" alt=\"Works with 70+ agents\"\u003e\n  \u003cimg src=\"https://img.shields.io/badge/license-MIT-111111?style=flat-square\" alt=\"MIT license\"\u003e\n\u003c/p\u003e\n\n---\n\nYou've worked with a 10x developer. They aren't 10x because they type faster\nor write more code. In fact, they usually write less. They're 10x because they\neliminate entire classes of problems instead of solving tickets one at a time.\nThey treat code as a liability - every line is a line that has to be tested,\ndebugged, secured, and maintained - so they maximize the amount of work not\ndone. They strip a problem to its fundamentals before touching a keyboard:\nwhat are the actual constraints? What's an assumption we can challenge? Does\nthis even need to exist?\n\nWhen something breaks, they don't guess-and-check. They read the logs, form a\nspecific hypothesis, isolate the variable, and write one targeted fix with a\nregression test. When they're about to build something, they mentally simulate\nthe failure modes first - cascading failures, race conditions, what happens\nunder backpressure. Every time they touch the codebase, the next engineer who\nopens it starts further ahead. Decisions get written down with the alternatives\nthat were rejected. Dead\nends get documented so nobody walks down them twice. Specs are precise enough\nthat someone else can verify the behavior independently.\n\nThat's not extra process. That's how they multiply the team. A junior engineer\nonboards faster because the ADRs exist. A teammate picks up the work cold\nbecause the reasoning is in the repo, not in someone's head. The next person\ndoesn't re-evaluate a settled decision because the tradeoffs are written down\nin plain English.\n\nRight now, your AI agent operates at the opposite end of this spectrum. It's\na brilliant syntax generator with zero engineering judgment. Every session\nstarts from scratch. Vague instructions pass without pushback. It solves the\nimmediate ticket without considering whether the ticket should exist, says\n\"done\" because a command exited zero, and forgets everything it learned the\nmoment you close the chat. Next session, you're explaining the same\narchitectural context for the fourth time.\n\n10x is a skill that makes your agent operate the way that developer operates.\nNot by typing faster - by thinking more carefully. When requirements are\nunclear, your agent pushes back, asking the questions a principal engineer\nwould ask before writing a line of code. It searches the project for existing\nanswers before bothering you, breaks work into pieces small enough to check\nindependently, and captures evidence of what actually happened - observed\noutput, not \"I believe it works.\" It challenges its own work before calling\nit done. And because working this way naturally produces documentation, the\nreasoning accumulates in `.10x/` as structured engineering records that any\nfuture agent (or human) can pick up cold.\n\nThursday's agent uses Tuesday's judgment because Tuesday's agent worked\ncarefully enough to leave a trail.\n\nThis is my personal instruction set - the base instructions I load into every\ncoding harness I use. It's opinionated, it's what works for me, and I'm\nsharing it because it might work for you too.\n\n[Read the full instructions](SKILL.md) | [Install](#installing)\n\n## What still gets lost\n\nMaybe your workflow already has good parts. Plan mode, spec files, custom\nskills, subagents reviewing subagents. You've built a small ecosystem. But the\npieces haven't learned each other's names, and the agent still operates like a\nticket machine - accepting work at face value, executing in isolation, and\ndeclaring victory without verification.\n\n| You already use | What still goes wrong |\n| --- | --- |\n| Plan mode | Reasoning disappears with the session |\n| `PLAN.md` or spec files | Plans rarely link to evidence, reviews, or later decisions |\n| Subagents | Reports sound authoritative before anyone verifies them |\n| Custom skills | They use different state and vocabulary from each other |\n| \"Think before coding\" prompts | The agent still guesses when requirements are vague |\n| Chat history | Important conclusions stay implicit, private, or impossible to grep |\n\nThe gap isn't tooling. It's judgment. 10x gives the agent a complete working\nmethod where these problems don't arise because the behaviors that prevent them\nalso produce the records that survive.\n\n## How a 10x developer works (and how 10x makes your agent work)\n\nA 10x developer separates understanding from execution. It's a discipline:\nknowing when you have enough clarity to proceed and when you don't.\n\nWhen requirements are unclear, the agent stays in the outer loop. It searches\nthe codebase and existing records for answers before asking you anything. It\ninterrogates vague terms and challenges unstated assumptions - the way a\nprincipal engineer who's been burned enough times refuses to let \"it should\njust work\" pass without defining what \"work\" means. As things get clearer,\ndecisions get recorded with their alternatives, specs get written with\ntestable behavior, and research documents what was tried and what dead-ended.\nA decision without recorded rationale is a decision the next person will\nre-evaluate from scratch.\n\nWhen the work is clear enough that a new teammate could pick it up without\nguessing at requirements, a bounded ticket enters the inner loop. The agent\ntreats execution the way a careful engineer treats a production deployment:\nobserve what actually happens, capture the evidence, compare it against the\nstated criteria, and don't declare success until they match. Subagent output is\ntreated as a hypothesis until evidence confirms it - the same way a senior\nengineer treats a junior's \"it's fixed\" as a claim that needs a reproduction\ntest.\n\nWhen a ticket closes, the agent runs a retrospective - because the most\nexpensive thing in engineering is paying the same cost twice. Discoveries\nbecome permanent knowledge, recurring friction becomes a reusable skill, and\nfollow-up work gets its own ticket. The team's capability compounds.\n\n```mermaid\nflowchart TB\n  Goal[\"human goal\"]\n  Goal --\u003e Outer[\"outer loop: clarify, specify, record\"]\n  Outer --\u003e Tickets[\"bounded tickets\"]\n  Tickets --\u003e Inner[\"inner loop: execute, prove, review\"]\n  Inner --\u003e|\"done + retro\"| Knowledge[\"knowledge compounds\"]\n  Inner --\u003e|\"new ambiguity\"| Outer\n```\n\n## What accumulates\n\nWhen an agent works this way, your repo grows a `.10x/` directory - the same\nkind of engineering context a 10x developer naturally leaves behind as they\nwork:\n\n```\n.10x/\n├── decisions/   # the \"why\" - choices with alternatives and rationale\n├── research/    # investigations, dead ends, things nobody should retry\n├── tickets/     # bounded work with scope, criteria, and progress\n├── evidence/    # what actually happened - terminal output, test results\n├── specs/       # behavioral contracts precise enough to verify against\n├── reviews/     # adversarial critique before anything ships\n├── knowledge/   # compounding vocabulary, conventions, and heuristics\n└── skills/      # hardened procedures the agent can reuse next time\n```\n\nRecords reference each other by file path - a ticket cites its spec, evidence\ncites its ticket, a decision points to the research that informed it. Plain\nMarkdown. Versioned by git. Greppable. Diffable. Reviewable in a PR.\n\nHere's a decision record:\n\n```markdown\nStatus: active\nCreated: 2025-06-12\nRelates-To: .10x/research/2025-06-10-jwt-vs-sessions.md\n\n## Context\n\nAPI needs authentication. Two options evaluated: JWT with refresh\ntokens, or session cookies backed by Redis.\n\n## Decision\n\nJWT with refresh tokens. Stateless, scales horizontally without a\nsession store, works for both browser and mobile clients.\n\n## Alternatives\n\nSession cookies: simpler auth flow, but requires shared Redis\ninstance and doesn't support mobile without workarounds.\n\n## Consequences\n\nNeed a token rotation strategy. Rotation interval is an open\nquestion tracked in the auth ticket.\n```\n\nThis record exists because the agent actually evaluated alternatives before\nchoosing - the same way a 10x developer wouldn't commit an architectural\nchoice without recording why the alternatives were rejected. A future agent\nreads this and starts working from the settled decision instead of re-deriving\nit from first principles.\n\n## Before and after\n\n**Without 10x:** Monday morning. New session. \"We decided on JWT with refresh\ntokens last week, remember?\" It doesn't. You spend fifteen minutes digging\nthrough old chat history, chasing the ghost of a decision that was already\nsettled. Then the agent starts implementing before clarifying two ambiguous\nrequirements - because nothing forced it to ask. You catch it three files\ndeep. Start over. You've now paid the cost of this decision twice with nothing\nto show for it.\n\n**With 10x:** Monday morning. New session. The agent reads the decision record,\nfollows the link to the research, picks up the open question about rotation\nintervals. Asks about that specifically - with a concrete recommendation and\nthe tradeoffs named. One answer and real work starts. Everyone starts further\nahead than yesterday, and nobody had to re-explain anything.\n\n## Why not RAG, vectors, or longer context windows?\n\nThose are retrieval mechanisms. They help the agent find relevant text in a\nlarge corpus. They don't change how the agent thinks or works.\n\nAn agent with a vector database still accepts vague requirements, still says\n\"done\" without verifying, still doesn't record why it chose one approach over\nanother. It just remembers slightly more of the raw conversation\nwhile repeating all the same judgment failures.\n\n10x is behavioral. The records it produces are useful for retrieval, but the\nbehavior that produces them - questioning assumptions, breaking down work,\nrecording what happened, proving it's actually done - is where the actual leverage comes from.\nThe same leverage that makes a human 10x.\n\n## Keep your current workflow\n\n10x doesn't replace your tools. It gives the agent a working method that\nnaturally coordinates across them.\n\n| Your workflow | How 10x integrates |\n| --- | --- |\n| Plan mode | Use it to think. What crystallizes goes into records. |\n| `PLAN.md` | Keep it canonical. A parent ticket points to it. |\n| Spec-driven development | Store in `.10x/specs/` or link to the canonical copy. |\n| Superpowers | Keep the methodology. 10x carries context across sessions. |\n| Custom skills | Source in `.10x/skills/`, mirrored to harness-native directories. |\n| External issue trackers | Keep delivery state there. 10x holds the local context. |\n\n## Installing\n\nIt's just instructions. Copy them into whatever file your agent reads at\nstartup.\n\n### Copy-paste (recommended)\n\nCopy the contents of [`SKILL.md`](SKILL.md) (minus the YAML frontmatter)\ninto whatever file your agent reads at startup:\n\n| Harness | File |\n| --- | --- |\n| OpenCode | `AGENTS.md` |\n| Claude Code | `CLAUDE.md` |\n| Cursor | `.cursor/rules/10x.md` or project rules |\n| Codex | `AGENTS.md` |\n| Gemini CLI | `GEMINI.md` |\n| Others | Whatever instruction file your agent reads |\n\nNo dependencies, no runtime. Zero ceremony.\n\n### Skills ecosystem\n\n```bash\nnpx skills add z3z1ma/10x\n```\n\nVercel skills CLI. Handles placement for 70+ coding harnesses including\nOpenCode, Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, Windsurf,\nRoo Code, and others.\n\n```bash\n# Install globally\nnpx skills add z3z1ma/10x -g\n\n# Target specific agents\nnpx skills add z3z1ma/10x -a claude-code -a opencode\n\n# Non-interactive\nnpx skills add z3z1ma/10x -g -a claude-code -y\n```\n\n### Manual clone\n\nClone the repo into whatever skill or rules directory your harness uses:\n\n```bash\n# Example for OpenCode\ngit clone https://github.com/z3z1ma/10x .opencode/skills/10x\n\n# Example for Claude Code\ngit clone https://github.com/z3z1ma/10x .claude/skills/10x\n```\n\n## When to use it\n\nA 10x developer doesn't pull out their full engineering discipline for a typo\nfix. Same principle. Use 10x when you'll touch the same codebase across\nmultiple sessions and context matters. Architecture decisions that need to\nsurvive handoffs. Bug investigations where reproduction steps are the whole\npoint. Multi-week features where four agents will touch the same subsystem.\n\nThe honest tradeoff: the skill is ~4000 words of instruction and the agent\nspends tokens on deliberation and record-keeping. For complex multi-session\nwork, this pays for itself immediately - fewer rework cycles, fewer\nre-explanations, fewer \"wait, didn't we already decide this?\" moments. For\none-shot scripts or throwaway prototypes, it's overhead you don't need.\n\n## FAQ\n\n**Does 10x replace Superpowers or other skill packs?**\nNo. Those often govern how the agent writes code or apply process pressure. 10x\ngoverns how the agent approaches work - when to clarify, when to execute, how\nto verify, and what to preserve. They compose naturally.\n\n**Is this too much process for small changes?**\nTrivial work stays trivial. The overhead scales with ambiguity and risk. The\ngoal is to stop paying the same cost twice.\n\n**Why Markdown?**\nHumans can read it. Agents can read it. Git can diff it. Grep can find it\nthree years from now. No vendor lock-in. No proprietary format. The lowest\ncommon denominator that happens to be good enough.\n\n## Composition\n\n`SKILL.md` is a single self-contained file, but it's built from three\ndistinct pieces:\n\n| Component | Source | What it does |\n| --- | --- | --- |\n| 10x Protocol | Original | The outer/inner loop, record shapes, retrospectives, and durable project memory system |\n| Tactical Guidelines | [Karpathy's LLM coding guidelines](references/KARPATHY.md) | Behavioral mechanics that reduce common LLM coding mistakes |\n| Operational Minimalism | Distilled from [ponytail](references/MINIMALIST.md) | Ruthless simplicity constraints and the execution ladder |\n\nThe `references/` directory contains the standalone source material. The skill\nembeds all three so that a single file is all any harness needs.\n\n## For agents\n\nIf you're an AI agent reading this to install 10x:\n\n1. Copy the contents of `SKILL.md` (excluding the YAML frontmatter) into the\n   project's instruction file (`AGENTS.md`, `CLAUDE.md`, or equivalent).\n2. Or: `npx skills add z3z1ma/10x` for skills directory installation.\n3. Self-contained once loaded. Read `.10x/` if it exists. If not, trigger the\n   outer loop when a request carries ambiguity worth recording.\n\n## Why \"10x\"?\n\nThe term has been around since 1968. Sackman, Erikson, and Grant found a 10:1\nratio in debugging efficiency between programmers at the same experience level.\nThat gap never closed. It widened. But what it measures shifted: a 10x\ndeveloper in 2025 isn't someone who writes 10x more code. They usually write\nless. They're 10x because they eliminate problems instead of solving them,\nmultiply the people around them through radical documentation, and make the\nnext engineer's job easier every time they touch something.\n\nWith AI agents handling syntax, that gap widens further. The mechanical act of\nwriting code is commoditized. What remains scarce is engineering judgment -\nknowing what to build, knowing when to stop, knowing how to prove it works,\nand leaving enough context that the next person doesn't start from zero.\n\nThat's the habit. This is the skill.\n\nCall it what you want. I thought it was funny.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fz3z1ma%2F10x","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fz3z1ma%2F10x","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fz3z1ma%2F10x/lists"}