Skip to content
Back to search

10x-cli

CLI tool for 10xDevs course content. Fetch and apply AI coding skills, prompts, and configs directly into your workspace.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/przeprogramowani/10x-cli with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/przeprogramowani/10x-cli'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/przeprogramowani-10x-cli/badge.svg)](/listings/przeprogramowani-10x-cli)

HTML

<a href="/listings/przeprogramowani-10x-cli"><img src="/api/listings/przeprogramowani-10x-cli/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

# Zero-install — run directly with npx (no global install needed)
npx @przeprogramowani/10x-cli auth
npx @przeprogramowani/10x-cli get m1l1

# Or install globally for shorter commands
npm install -g @przeprogramowani/10x-cli

# Or download a standalone binary from GitHub Releases
# https://github.com/przeprogramowani/10x-cli/releases

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 642 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # 10x-cli
  2. CLI tool for [10xDevs](https://10xdevs.pl) course content. Fetch and apply AI coding skills,
  3. prompts, and configs directly into your workspace.
  4. ## Requirements
  5. - **Node 20+** — this is the only runtime dependency.
  6. Corporate firewall / proxy allowlist (for security and sysadmin teams):
  7. Polish [docs/wymagania-sieciowe.md](docs/wymagania-sieciowe.md),
  8. English [docs/network-requirements.md](docs/network-requirements.md).
  9. ## Install
  10. ```bash
  11. # Zero-install — run directly with npx (no global install needed)
  12. npx @przeprogramowani/10x-cli auth
  13. npx @przeprogramowani/10x-cli get m1l1
  14. # Or install globally for shorter commands
  15. npm install -g @przeprogramowani/10x-cli
  16. # Or download a standalone binary from GitHub Releases
  17. # https://github.com/przeprogramowani/10x-cli/releases
  18. ```
  19. ## Install the bundled CLI helpers (unreleased)
  20. `10x helpers install` is implemented on this branch for the next CLI release;
  21. it is **not available in 1.21.0 or the 1.22.0 master baseline**. A checkout build
  22. may still print 1.22.0 until the release process assigns a version. Check
  23. `10x helpers --help` on your actual executable before using this command; do not
  24. assume that installing today's npm version includes it.
  25. Once your release includes it, run from the intended project directory:
  26. ```bash
  27. 10x helpers install --tool copilot --dry-run
  28. 10x helpers install --tool copilot
  29. ```
  30. This installs **both** `10x-cli-setup` and `10x-cli-guide`, each with its complete
  31. `SKILL.md` and `references/compatibility.md`, into `.github/skills/`. Use
  32. `--tool claude-code`, `cursor`, `codex`, `devin-desktop`, `factory`, `gemini`, `kiro`, or `generic`
  33. when that is your intended tool. The target must be explicit; installation is
  34. project-only. There is no `--global`, automatic agent detection, `skills`/npx
  35. subprocess, authentication, or network access. The helper bytes come from the
  36. same CLI build, including the standalone binary; fetching the npm CLI itself
  37. still requires npm/network in the usual way.
  38. Identical existing files are unchanged; missing files are created. If any existing
  39. helper file differs, neither helper is written and the command exits 1. Keep the
  40. existing copy or back up your changes outside managed skill directories before
  41. replacing it deliberately. Files managed by course `10x get`/`sync` remain under
  42. that channel; this command does not register or take over a course manifest.
  43. It never deletes extra local files. A filesystem failure also exits 1; any files
  44. already created remain, and rerunning safely checks them again. `--dry-run`
  45. performs the same path/conflict checks without writes. Invalid/missing targets or
  46. unsupported flags exit 2 in both human and JSON use.
  47. For Copilot CLI, run `/skills reload`, then `/skills info 10x-cli-setup` and
  48. `/skills info 10x-cli-guide` in the same project. Installing helpers does not
  49. execute them or authenticate the course CLI. VS Code Copilot also reads project
  50. `.github/skills`; open the same project there.
  51. To try the **unreleased source checkout** without changing a global installation:
  52. run `bun run /absolute/path/to/10x-cli/src/index.ts helpers install --tool copilot`
  53. from a disposable project, with dependencies already installed in the checkout.
  54. The public `skills` route below remains available for older CLI releases. Its
  55. Copilot agent ID is `github-copilot`, whereas this CLI uses `--tool copilot`.
  56. ## Agentic Installation
  57. The [`10x-cli-setup`](skills/10x-cli-setup/SKILL.md) helper prepares the CLI and
  58. passes project context to [`10x-cli-guide`](skills/10x-cli-guide/SKILL.md), which
  59. leads through download → an actual agent task → sync. Each ships its own
  60. [compatibility reference](skills/10x-cli-guide/references/compatibility.md).
  61. Installing the npm CLI does not activate these helpers in your agent.
  62. For public installation on demand, choose a full retained public CLI master SHA
  63. containing the helper version you want. From your project root (macOS/zsh):
  64. ```bash
  65. : "${CLI_SKILLS_REF:?Set the full public CLI master SHA containing the helpers}"
  66. npx --yes skills@1.5.26 add "https://github.com/przeprogramowani/10x-cli/tree/$CLI_SKILLS_REF/skills" --skill 10x-cli-setup --agent claude-code --copy
  67. # Install guide when needed using the same channel:
  68. npx --yes skills@1.5.26 add "https://github.com/przeprogramowani/10x-cli/tree/$CLI_SKILLS_REF/skills" --skill 10x-cli-guide --agent claude-code --copy
  69. ```
  70. These are project copies. Installer prompts remain enabled; `npx --yes` only
  71. accepts running the pinned tool. Inspect the actual installed paths and ask the
  72. agent to read that SKILL.md and its references. No automatic discovery is assumed.
  73. Both helpers can also be downloaded through the CLI once filtered get is supported
  74. by your verified release and v4 m1l1 content is published and accessible. In a
  75. separate project from public copies, after setup/auth:
  76. ```bash
  77. : "${CLI_VERSION:?Set the actual verified published CLI version}"
  78. 10x_cli() { npx --yes "@przeprogramowani/10x-cli@$CLI_VERSION" "$@"; }
  79. 10x_cli --version
  80. 10x_cli get --help
  81. 10x_cli get m1l1 --type skills --name 10x-cli-setup --tool claude-code --lang pl --dry-run
  82. 10x_cli get m1l1 --type skills --name 10x-cli-setup --tool claude-code --lang pl
  83. 10x_cli get m1l1 --type skills --name 10x-cli-guide --tool claude-code --lang pl --dry-run
  84. 10x_cli get m1l1 --type skills --name 10x-cli-guide --tool claude-code --lang pl
  85. ```
  86. Source membership does not prove publication. Confirm skill-filter support and direct
  87. sync against the actual package and content; do not infer it from a version label
  88. or silently replace the name with a full lesson. CLI-owned copies update through
  89. sync; public copies update through a deliberate new source SHA and pinned add.
  90. The CLI executable has its own npm/binary update procedure.
  91. Keep one updater per copy. Before either route, inspect destination paths/symlinks
  92. and CLI/installer ownership. For public→CLI takeover, back up the whole helper
  93. outside managed trees, unregister only that helper through the original installer,
  94. verify its destination and registration are gone, then filtered get. Preserve local
  95. edits for conscious merging. For CLI→public use a new project; no verified CLI
  96. per-skill unregister is promised. See the compatibility reference for details.
  97. ## Quick Start
  98. Use an existing verified global/standalone `10x`, or the pinned `10x_cli` runner
  99. above. Retain your v3 project and use a separate v4 exercise directory. Leave
  100. `--course` out: an unbound directory takes the highest edition your account can
  101. reach, a bound one keeps its own, and `10x doctor` reports which edition this
  102. project is on. After checking skill-filter capability and content availability. Sync later refreshes
  103. whole downloaded lessons, so inspect its preview and accept any additional
  104. artifacts/rules before applying; repeat a skill filter for a narrow update:
  105. ```bash
  106. 10x_cli auth --status
  107. # If login is needed: 10x_cli auth (email or Circle); see auth commands below.
  108. 10x_cli list
  109. 10x_cli get m1l1 --type skills --name 10x-idea-check --tool claude-code --lang pl --dry-run
  110. 10x_cli get m1l1 --type skills --name 10x-idea-check --tool claude-code --lang pl
  111. 10x_cli get m1l1 --type skills --name 10x-init --tool claude-code --lang pl --dry-run
  112. 10x_cli get m1l1 --type skills --name 10x-init --tool claude-code --lang pl
  113. 10x_cli get m1l1 --type skills --name 10x-shape --tool claude-code --lang pl --dry-run
  114. 10x_cli get m1l1 --type skills --name 10x-shape --tool claude-code --lang pl
  115. 10x_cli get m1l1 --type skills --name 10x-prd --tool claude-code --lang pl --dry-run
  116. 10x_cli get m1l1 --type skills --name 10x-prd --tool claude-code --lang pl
  117. # Follow the guide: read each installed SKILL.md and references, then
  118. # init → shape with the learner’s 10xCards inputs → PRD from approved notes.
  119. 10x_cli sync --tool claude-code --lang pl --dry-run
  120. 10x_cli sync --tool claude-code --lang pl
  121. 10x_cli doctor
  122. ```
  123. The guide uses lesson 1's existing 10xCards example and produces
  124. `context/foundation/shape-notes.md`, then `context/foundation/prd.md`.
  125. Lesson setup installs all four skill trees. Use `10x-idea-check` and its references
  126. first when you want to assess an idea; it is optional before init → shape → PRD.
  127. Read the installed entrypoints and their references; PRD requires the sibling
  128. `.claude/skills/10x-shape/references/prd-schema.md`. Preserve existing outputs and
  129. follow the skills' collision choices. `CLAUDE-m1l1` is a separate lesson rule;
  130. see the guide for prerequisite checks without a full-get fallback. `10x-plan`
  131. is not available for this launch demonstration. CLI 1.21.0 and v4 m1 EN/PL are
  132. published; these revised helpers remain a separate source change. Verify each
  133. filtered preview and complete PL references before the walkthrough. A download alone is not successful skill use.
  134. Inspect sync conflicts even on exit 0; never apply automatic `--force`. A missing
  135. tool directory before first get can explain that doctor check; other failures
  136. remain visible. Full lesson downloads and other commands remain available below.
  137. ## Commands
  138. | Command | Description |
  139. |---------|-------------|
  140. | `10x auth` | Magic-link login with your Circle-registered email |
  141. | `10x auth --method circle` | No email received? Get the approval link as a Circle message instead |
  142. | `10x list` | Browse modules and lessons in your course |
  143. | `10x get <ref>` | Fetch a lesson and apply artifacts to your workspace |
  144. | `10x sync` | Bulk-download / refresh lessons and report what changed upstream |
  145. | `10x changelog` | Show 10x-toolkit release notes since your last sync |
  146. | `10x skill <name>` | Explain a skill: problem, solution, when to use it, what it produces, related skills |
  147. | `10x skill <name> --install` | Install one course skill without naming a lesson |
  148. | `10x skill-group <name>` | Explain a group of skills, e.g. `core-skill-chain`; `--install` writes all of them |
  149. | `10x doctor` | Diagnose auth, API connectivity, and local config |
  150. | `10x bench` | Live top-10 AI model leaderboard from [10xbench.ai](https://10xbench.ai) — no login needed |
  151. | `10x bench-kit <action>` | Create (`init`) and update (`update`) a company benchmark instance from the [10x-bench-kit](https://github.com/przeprogramowani/10x-bench-kit) template |
  152. ### `10x get` Flags
  153. | Flag | Description |
  154. |------|-------------|
  155. | `--tool <tool>` | AI coding tool: `claude-code`, `cursor`, `copilot`, `codex`, `devin-desktop`, `gemini`, `kiro`, `factory`, `generic` |
  156. | `--print` | Output artifact content to stdout instead of writing files |
  157. | `--type <type>` | Filter by artifact type: `skills`, `prompts`, `rules`, `configs` |
  158. | `--name <name>` | Filter by artifact name (requires `--type`) |
  159. | `--dry-run` | Show what would be written without touching the filesystem |
  160. | `--course <slug>` | Select an entitled course ID or slug; default is the project edition or API recommendation |
  161. | `--no-course-rules` | Skip the course rules block in your rules file (`CLAUDE.md`/`AGENTS.md`); removes an unchanged block whose ownership and baseline are known. Broken or duplicate markers are left untouched so skills and prompts can still apply. Use `--course-rules` to re-enable. |
  162. #### Examples
  163. ```bash
  164. # Fetch full lesson — writes skills, prompts, rules, configs
  165. 10x get m1l1
  166. # Write only skills (skip prompts, rules, configs)
  167. 10x get m1l1 --type skills
  168. # Write a single artifact
  169. 10x get m1l1 --type skills --name code-review
  170. # Print to stdout (pipe-friendly)
  171. 10x get m1l1 --print --type skills --name code-review
  172. 10x get m1l1 --print --type skills --name code-review | pbcopy
  173. # Use with a different AI coding tool
  174. 10x get m1l1 --tool cursor
  175. # Skip the course rules block (use only your rules). Persisted across runs;
  176. # an unchanged block with a known baseline is removed. Re-enable later with --course-rules.
  177. # Also the recovery path when CLAUDE.md markers are broken (orphan/duplicate).
  178. 10x get m1l1 --no-course-rules
  179. 10x get m1l2 --course-rules
  180. # An explicit rules request always applies, even with the opt-out persisted
  181. 10x get m1l1 --type rules
  182. ```
  183. > The `--no-course-rules` / `--course-rules` choice is saved as `courseRules`
  184. > in `config.json` and applies to subsequent plain `10x get` runs. An explicit
  185. > `--type rules` request overrides the opt-out for that run. Skills, prompts,
  186. > and config-templates are unaffected.
  187. ### `10x sync`
  188. `10x sync` keeps your downloaded lessons up to date and tells you **what changed
  189. upstream** since you last fetched. By default it refreshes only the lessons you've
  190. already downloaded; `--all` pulls every unlocked lesson at once.
  191. Unchanged lessons are skipped **without a download** — the catalog advertises a
  192. per-lesson `contentHash` that the CLI compares against what it last applied, so the
  193. common "nothing changed" case avoids lesson downloads. Skipping also requires the same language/tool/rules representation and intact tracked local files; missing files are repaired and local edits still surface as conflicts.
  194. | Flag | Description |
  195. |------|-------------|
  196. | `--all` | Sync every unlocked lesson, not just the ones you've downloaded |
  197. | `--module <m>` | Limit to one module (e.g. `m2` or `2`) |
  198. | `--dry-run` | Preview what would change without writing anything |
  199. | `--force` | Fetch again and overwrite local skill/prompt edits; protected rules and config templates remain guarded |
  200. | `--tool <tool>` | AI coding tool (same set as `get`) |
  201. | `--lang <lang>` | Content language: `en` (default) or `pl` |
  202. | `--course <slug>` | Select an entitled course ID or slug; default is the project edition or API recommendation |
  203. | `--no-course-rules` | Skip the course rules block (same semantics as `get`) |
  204. ```bash
  205. # Refresh everything you've already downloaded; report what moved
  206. 10x sync
  207. # Pull every unlocked lesson in one shot (fresh project)
  208. 10x sync --all
  209. # Preview changes without writing
  210. 10x sync --dry-run
  211. # Only module 2
  212. 10x sync --module m2
  213. # Take all upstream updates, overwriting local edits
  214. 10x sync --force
  215. ```
  216. The report classifies every resource as **upstream-updated**, **created**,
  217. **unchanged**, **skipped (conflict)**, or **removed**. When a file you edited
  218. locally also changed upstream, sync **keeps your edit** and prints the exact
  219. command to take the update, e.g.:
  220. ```
  221. m2l3 — conflicts (1 skipped)
  222. skipped skills/auth-skill (SKILL.md) — you edited it → 10x get m2l3 --type skills --name auth-skill
  223. ```
  224. Run that `10x get …` to take a single update, or `10x sync --force` to take them
  225. all for skills and prompts. Config templates are create-only. Course rules retain a separate upstream baseline: local edits or a missing baseline require explicit resolution, including when `--force` or `--no-course-rules` is used. Text outside the managed markers is preserved.
  226. **Exit code is worst-outcome:** `0` when everything is clean/unchanged (a skipped
  227. conflict is reported, not a failure), `1` if any lesson failed to fetch. The full
  228. report is still emitted on a partial failure.
  229. ### `10x changelog`
  230. `10x changelog` shows the **10x-toolkit release notes** — which course skills,
  231. prompts, rules and config templates changed in each toolkit release — since your
  232. project's baseline. It describes toolkit releases, not your files: to see what a
  233. sync would actually download or update in this project, run `10x sync --dry-run`.
  234. It needs a login and never writes anything.
  235. The changelog follows the project's course, the same one `get` and `sync` use
  236. (`.10x-cli.json`, or the course in a tool manifest): a 10xDevs 3.0 project lists only
  237. releases that reached 3.0, even when your account also has 4.0. Outside a project it
  238. lists the releases of every course you have. A project whose files disagree on the
  239. course stops with `course_binding_conflict`, as `get`/`sync` do.
  240. The baseline is recorded per project: after a successful `10x sync` (not
  241. `--dry-run`, no failed lessons) or a full, unfiltered `10x get`, the CLI stores the newest
  242. toolkit release of the project's course in the project manifest (`toolkit.version`), or
  243. removes a stored one when that course has no published release. If the
  244. backend cannot answer, nothing is recorded and the sync/get result is unchanged.
  245. Without a recorded version, `10x changelog` falls back to the date of the last
  246. lesson applied in the project; in a project with no manifest it shows the latest 5
  247. releases and suggests running `10x sync`.
  248. | Flag | Description |
  249. |------|-------------|
  250. | `--since <ref>` | Ignore the baseline: `vX.Y.Z` lists releases **after** that version; `YYYY-MM-DD` lists releases **from** the start of that UTC day |
  251. | `--course <course>` | Show one course's releases instead of this project's course (e.g. `10xdevs4`) |
  252. | `--limit <n>` | Maximum number of releases, 1-100 (default 20; 5 without a baseline) |
  253. ```bash
  254. # What changed in the toolkit since this project's last sync
  255. 10x changelog
  256. # Browse history regardless of the baseline
  257. 10x changelog --since v2.55.0
  258. 10x changelog --since 2026-10-01 --limit 50
  259. ```
  260. The output starts with where the project stands (for example `This project is on
  261. toolkit v2.59.2 (recorded by 10x sync on 2026-10-05) — 2 newer releases:`), then
  262. lists releases newest first: `vX.Y.Z — <date>`, the release highlights as bullets,
  263. and the changed skills, prompts, rules and config templates with a status mark
  264. (`+` new, `~` changed, `-` removed, `>` renamed) and a one-line summary. Colours are
  265. used only on an interactive terminal and respect `NO_COLOR`. Exit code is `0`
  266. whether or not there are new releases; an invalid `--since`/`--limit` exits `2`, a
  267. missing login `3`, and an account without access to the course `4`. Against
  268. a backend that does not serve the changelog yet the command fails with
  269. `changelog_unsupported` (exit `1`); `get` and `sync` keep working. JSON output
  270. (`--json` or piped) is `{ baseline: { source, version?, date?, recordedAt? },
  271. course, newEntries, entries }` (`course` is `null` outside a project), where `source` is `flag`, `sync`, `applied` or `none`.
  272. ### `10x skill <name>`
  273. `10x skill <name>` is a terminal glossary of the course skills: what a skill is for and
  274. where it sits in the 10x workflow, short enough to read next to your work. It needs a
  275. login and never writes anything.
  276. ```bash
  277. 10x skill 10x-plan
  278. 10x skill plan --lang pl # the 10x- prefix and a leading / are optional
  279. ```
  280. ```text
  281. /10x-plan
  282. Core chain, step 3: after research, before implement
  283. Problem Agents that code without a plan make key decisions silently, and you find
  284. them in the diff when they are expensive to undo.
  285. Solution Interviews you with recommendations, forces decisions while they are cheap,
  286. and writes phases with success criteria.
  287. Use when Before implementing any change bigger than a quick fix.
  288. Produces context/changes/<change-id>/plan.md
  289. Phases, success criteria and the Progress checklist
  290. Related /10x-research Gathers the evidence the plan is built on
  291. /10x-plan-review Challenges the plan before any code
  292. /10x-implement Executes the plan phase by phase
  293. ```
  294. | Flag | Description |
  295. |------|-------------|
  296. | `--lang <lang>` | `en` or `pl` (default: your configured language, then `en`) |
  297. There is no `--course` flag (passing one is a usage error, exit `2`): the command looks
  298. in this project's course, else in everything your account can reach. Overviews are generated by the toolkit from each
  299. skill's `SKILL.md` and refresh when that skill changes on its master branch, so a frozen
  300. course's copy of a skill can be older than its overview. An unknown name exits `5` with
  301. `skill_overview_not_found` and suggests close names; invalid usage exits `2`, a missing
  302. login `3`, and an account without access `4` ("You are not permitted to install this
  303. skill. Contact the support team at kontakt@przeprogramowani.pl."). A backend that does not serve
  304. overviews yet fails with `skill_overviews_unsupported` (exit `1`). JSON output (`--json`
  305. or piped) is `{ course, overview: { name, language, updatedAt, stage, problem, solution,
  306. whenToUse, artifacts: [{ path, purpose }], related: [{ name, why }] } }`.
  307. ### `10x skill <name> --install` and `10x skill-group <name>` (unreleased)
  308. Install one course skill, or a whole group of them, without knowing which lesson
  309. delivers it. `--install` is what writes; without it `10x skill` shows the overview above
  310. and `10x skill-group` shows the group's summary and its members in order.
  311. ```bash
  312. 10x skill 10x-plan --install # one skill, for your configured tool
  313. 10x skill 10x-plan --install --tool codex --dry-run
  314. 10x skill-group core-skill-chain # what is in the group
  315. 10x skill-group core-skill-chain --install # every member of the group
  316. ```
  317. ```text
  318. From lesson m5l5
  319. Wrote to .claude/:
  320. [created] 10x-frame
  321. [created] 10x-research
  322. [unchanged] 10x-plan (2 files)
  323. [conflict: skipped] 10x-plan-review
  324. [managed by lesson m2l1] skill 10x-implement — update with '10x get m2l1' or '10x sync'
  325. [created] 10x-impl-review
  326. ```
  327. `core-skill-chain` is the Core Skill Chain: `10x-frame`, `10x-research`, `10x-plan`,
  328. `10x-plan-review`, `10x-implement` and `10x-impl-review`.
  329. | Flag | Description |
  330. |------|-------------|
  331. | `--install` | Write the skill (or every member of the group) into this project |
  332. | `--dry-run` | With `--install`: report what would change without writing |
  333. | `--tool <tool>` | With `--install`: AI coding tool (default: your configured tool, then detection or a prompt) |
  334. | `--lang <lang>` | `en` or `pl` (default: your configured language, then `en`) |
  335. There is no `--course` flag (passing one is a usage error, exit `2`). In a project that
  336. already has course content, the install asks for that course's copy; otherwise the
  337. server picks from what your account can reach.
  338. What an install does:
  339. - **Same content as `10x get`.** The skill bytes come from one lesson bundle, named in
  340. the report (`From lesson …`) and in `sourceLessonId`. A group never mixes lessons.
  341. - **Same schedule as `10x get`.** Through a course, a skill or group is available once a
  342. lesson that delivers it is in an unlocked module, and the newest such lesson supplies
  343. it. Before that the install exits `4` with `skill_locked`: "'<name>' unlocks with
  344. module N on <date>.", or "'<name>' isn't available yet." when no future date is known.
  345. A license reaches every skill and group with no module check.
  346. - **Same conflict protection.** A file you edited is never silently replaced: in a
  347. terminal you choose overwrite, save as `.user`, skip or apply to all; piped or in CI the
  348. edit is kept and reported as `conflict_skipped`. Re-running the command updates files
  349. you did not edit and reports the rest as `unchanged`. There is no `--force`.
  350. - **A lesson wins.** A skill that a lesson you downloaded already owns is not written
  351. again; it is reported as `managed_by_lesson` with that lesson, so `10x get <lesson>` and
  352. `10x sync` keep updating it.
  353. - **Groups follow upstream.** When a group drops a member, the next group install
  354. removes that member's files only if you did not edit them and no lesson or other
  355. install still owns them. A single-skill install never removes anything.
  356. - **No project binding.** An install never creates or changes `.10x-cli.json`. In a
  357. project already bound to a course it still requires that course (`course_mismatch`
  358. otherwise); in a fresh project the manifest records the course that served the skill.
  359. - **Not part of `sync`.** `10x sync` refreshes lessons only; run the install again to
  360. update an installed skill or group. It also never touches your course rules file.
  361. An unknown skill or group exits `5` (`skill_not_found` / `skill_group_not_found`, with
  362. close names in the hint), invalid usage `2` (including `--course`, and `--dry-run` or
  363. `--tool` without `--install`), a missing login `3`, a locked skill `4` (`skill_locked`),
  364. and an account without access `4` (`skill_access_denied`, `course_access_denied`, or
  365. `course_not_found` from a stale project binding), which prints "You are not permitted to
  366. install this skill. Contact the support team at kontakt@przeprogramowani.pl." (or "this
  367. skill group"). A backend without these routes fails with
  368. `skill_install_unsupported` or `skill_groups_unsupported` (exit `1`); use
  369. `10x get <lesson> --type skills --name <skill>` there. JSON output (`--json` or piped) is
  370. `{ skill | group, course, grantedBy: { kind: "course" | "license", id }, sourceLessonId, result: { tool,
  371. language, dry_run, skills: [{ name, files: [{ path, absolutePath, action,
  372. ownerLessonId? }] }], removals } }`; the group overview is `{ course, group: { id,
  373. title, summary, skills, courses } }`.
  374. ### `10x bench`
  375. Shows the [10xBench](https://10xbench.ai) leaderboard — the top 10 AI models
  376. benchmarked on vibe-coding the Przeprogramowani.pl website — rendered as
  377. color-coded score bars in your terminal. Public data, works without logging in.
  378. ```bash
  379. 10x bench # Top 10 models with scores, runs, and cost per run
  380. 10x bench --limit 5 # Just the top 5
  381. 10x bench --json # Machine-readable (also auto-selected when piped)
  382. ```
  383. The data refreshes whenever new benchmark results are published on 10xbench.ai.
  384. Colors honor `NO_COLOR` and are disabled automatically when output is piped.
  385. ### `10x bench-kit`
  386. Creates and maintains a **company benchmark instance** from the
  387. [10x-bench-kit](https://github.com/przeprogramowani/10x-bench-kit) template —
  388. a self-hosted benchmark that scores AI agents on tasks embedded in your own
  389. repositories. The CLI is a thin installer/updater; tasks, assertions, and
  390. scoring live in the template and the instance.
  391. | Action | Description |
  392. |--------|-------------|
  393. | `init [dir]` | Materialize a fresh instance from the template (no git history, fresh `git init`), register the detected base repo, install runner dependencies, check the machine (`bench doctor`). Without `dir`, inside a product repo the instance goes to `../<repo>-bench` |
  394. | `update [dir]` | Upgrade the instance to a newer template: runtime zone replaced wholesale, skills proposed as a reviewable diff, company content untouched |
  395. | Flag | Description |
  396. |------|-------------|
  397. | `--template-version <tag>` | Template tag to install (default: latest) |
  398. | `--tool <id>` | Agent tool for skill placement (`claude-code`, `cursor`, `copilot`, `codex`, `devin-desktop`, `gemini`, `kiro`, `factory`, `generic`) |
  399. | `--yes` | Run non-interactively, accepting defaults |
  400. | `--shallow` | Clone the detected base repo at HEAD only (default: full history, which PR mining reads) |
  401. | `--deep` | Full history — the default since template 0.34.0; kept for older templates |
  402. ```bash
  403. # Create an instance next to your product repo (run inside it to auto-register)
  404. cd my-product && 10x bench-kit init # → ../my-product-bench
  405. # Non-interactive (CI, agent shells): pick the tool explicitly
  406. 10x bench-kit init --tool claude-code --yes
  407. # Pin the template version
  408. 10x bench-kit init my-benchmark --template-version v0.33.0
  409. # HEAD-only base repo clone (huge history you do not want to copy)
  410. 10x bench-kit init my-benchmark --shallow
  411. # Upgrade an existing instance to the latest template
  412. 10x bench-kit update
  413. ```
  414. A detected base repo is cloned into the instance's `.repos/<name>/` (gitignored)
  415. as a working copy for the authoring skills. It keeps the **full history**, because
  416. PR mining (the default source of tasks) reads it; cloning from your local working
  417. copy hardlinks the objects, so it takes seconds. `--shallow` keeps HEAD only, and
  418. `git fetch --unshallow` inside the clone adds the history later.
  419. When init finishes, it prints the exact first prompt to give your agent inside the
  420. instance (and `data.nextStep` in `--json` mode).
  421. Maintainers can point init/update at an unreleased template with
  422. `BENCH_KIT_TEMPLATE_URL=<git url or local checkout> 10x bench-kit init … --template-version <branch>`.
  423. Re-running `init` on an existing instance is a **repair**: missing template
  424. files are restored, company content is never touched. `update` ends the same
  425. way as init: with the prompt for your agent (`bench-status`, which re-validates
  426. the instance against the new kit) and a link to the installed release's notes.
  427. ### Global Flags
  428. - `--json` — Machine-readable JSON output (auto-detected when piped)
  429. - `--verbose` — Request/response diagnostics on stderr
  430. - `--version` — Print CLI version
  431. - `--help` — Show help
  432. ### Lesson References
  433. Lessons are referenced by module and lesson number:
  434. - `m1l1` — Module 1, Lesson 1
  435. - `m2l3` — Module 2, Lesson 3
  436. ### Multi-Tool Support
  437. On first run, the CLI prompts you to choose your AI coding tool. Artifacts are written to the correct directory for your tool:
  438. | Tool | Directory | Rules file |
  439. |------|-----------|------------|
  440. | Claude Code | `.claude/` | `CLAUDE.md` |
  441. | Cursor | `.cursor/` | `.cursor/rules/10x-course.mdc` |
  442. | GitHub Copilot | `.github/` | `.github/copilot-instructions.md` |
  443. | Codex CLI | `.agents/` | `AGENTS.md` |
  444. | Devin Desktop | `.devin/` | `AGENTS.md` |
  445. | Gemini CLI | `.gemini/` | `GEMINI.md` |
  446. | Kiro | `.kiro/` | `AGENTS.md` |
  447. | Factory AI | `.factory/` | `AGENTS.md` |
  448. | Generic | `.ai/` | `AGENTS.md` |
  449. Override with `--tool <name>`. Validated writing commands save your choice in `~/.config/10x-cli/config.json`. Previews leave it unchanged.
  450. The former `windsurf` ID remains accepted as an alias and is upgraded to
  451. `devin-desktop`; existing `.windsurf/` artifacts can be migrated by the normal
  452. tool-switch prompt.
  453. Factory AI stores skills in `.factory/skills/`, prompts in
  454. `.factory/commands/<name>.md` as custom slash commands, and config templates in
  455. `.factory/config-templates/`. Prompt names and bytes are preserved. Config
  456. templates are only a staging location; the CLI does not activate or merge them.
  457. Factory requests the generic content variant from the delivery API while its
  458. manifest records `factory`. It is auto-detected from `.factory/` (including its
  459. manifest, `skills/`, or `commands/`); `AGENTS.md` alone does not identify
  460. Factory.
  461. Factory shares root `AGENTS.md` with Codex CLI, Devin Desktop, Kiro, and Generic.
  462. The managed course-rules block can be shared only when its bytes are identical.
  463. Factory and Generic use the same generic content, but incompatible Codex or
  464. Devin rules stay protected even when an overwrite is requested.
  465. ## Development
  466. ```bash
  467. bun install
  468. bun run dev -- --help # Run CLI from source
  469. bun run build # Build dist/index.mjs (node target)
  470. bun run build:binary # Build standalone binary (~59MB)
  471. bun test # Run tests
  472. bun run typecheck # tsc --noEmit
  473. bun run lint # oxlint
  474. ```
  475. ## Contributing
  476. 1. Fork the repository
  477. 2. Create a feature branch (`git checkout -b feat/my-feature`)
  478. 3. Commit using [conventional commits](https://www.conventionalcommits.org/) (`feat:`, `fix:`, etc.)
  479. 4. Push and open a pull request
  480. CI runs lint, typecheck, tests, and build checks on every PR. Releases are automated on merge to `master` via conventional-commit analysis.
  481. ## License
  482. MIT
  483. ## Course selection and project edition
  484. `get`, `list`, and `sync` select the explicit `--course` first, then the project's edition, then the live API recommendation. A new project with only v3 access selects v3, with only v4 selects v4, and with both selects published, available v4. An unpublished v4 can leave v3 as the recommendation; network or backend failures are reported instead of falling back. Output includes the course and selection reason.
  485. The first validated write records `{ "version": 1, "course": "10xdevs4" }` (or `10xdevs3`) in the root `.10x-cli.json`, shared across AI tool profiles. Existing supported v2/v3 manifests preserve their recorded edition. All profiles, including legacy Windsurf, must agree. Corrupt, unknown-version, or conflicting manifests block writes and must be preserved for repair. Artifact names never infer an edition.
  486. Ordinary `get` and `sync` cannot change a bound project's edition. Start v4 in a separate directory while retaining the v3 project. Read-only inspection of another entitled edition is allowed with `--course`. Do not delete the binding or manifests to bypass an edition conflict. Course edition and manifest schema version are separate concepts.
  487. `list`, `get --print`, `get --dry-run`, `sync --dry-run`, and `doctor` preserve project files and tool/language preferences, including interactive tool choices. Auth token rotation may update only the credential store. Failed download, signature, course, or path validation leaves a new project unbound. Once writing starts, its binding remains even if an I/O operation fails, so retry stays on the same edition. `auth --status` and `doctor` distinguish token expiry from live course access.
  488. ## Candidate verification and v4 release
  489. Using v4 requires a CLI version with course discovery and project edition binding.
  490. Existing v3 projects remain usable without a new flag or an edition migration.
  491. Start v4 in a separate project directory; this release includes no edition migration
  492. command. Support files inside each skill directory are downloaded together with
  493. `SKILL.md`, including selector and stack-assessment references.
  494. Before publication, CI tests the exact CLI and Toolkit candidate commits together
  495. on Linux and Windows using real local auth callback, polling and token refresh.
  496. It also exercises the actual released npm 1.20.0 CLI against the candidate API and
  497. this candidate against existing v2/v3-manifest projects. Automated fixtures send no
  498. emails. npm latest or a different branch cannot stand in for the candidate binary.
  499. The private Toolkit release runbook `docs/how-to/release-10xdevs4-cli.md` documents
  500. the required full candidate SHA pair, vetted v3 fixture artifact, exact v4 stage
  501. and secured preparation Worker/content revisions. Publication depends on the
  502. coordinated gate plus normal Linux/Windows tests, builds and smoke checks. The
  503. operator must still verify secured production access and final v4 content before
  504. npm publication; passing a local test does not execute that rollout.
  505. For deterministic contract checks, export `/openapi.json` from the exact local
  506. candidate Worker, then run:
  507. ```bash
  508. OPENAPI_SPEC_PATH=/absolute/candidate-openapi.json bun run generate-types --check
  509. ```
  510. Check mode reads that file and compares the generated result without changing
  511. `src/generated/api-types.ts`. To regenerate, omit `--check` while keeping the same
  512. source file. Do not regenerate candidate contracts from the production API.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.