atlas-help
/atlas-help
Pokazuje kartę referencyjną ATLAS z czterema pokrętłami, poleceniami, podagentami i kosztami każdego z nich.
- Autor
- Z0CC0 ↗
- Repozytorium
- ATLAS-max ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 03.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 03.11.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Pokazuje kartę referencyjną ATLAS z czterema pokrętłami, poleceniami, podagentami i kosztami każdego z nich.
Wyzwalacze z opisu
Oryginalny opis (EN)
Show the ATLAS reference card: the four dials, every command, every subagent, what each costs. Use when the user asks for atlas help, "/atlas-help", "atlas commands", "how do I switch atlas" — in any language — or what modes exist.
Jak działa
- Dials
- Commands
- Coding and documents section — atlas-code and atlas-max
- Memory section — atlas-mem and atlas-max
- Video section — atlas-video and atlas-max
- Subagents
- Builds
- The per-turn reminder
- Configuration
Podgląd SKILL.md
---
name: atlas-help
description: >
Show the ATLAS reference card: the four dials, every command, every subagent, what each
costs. Use when the user asks for atlas help, "/atlas-help", "atlas commands", "how do I
switch atlas" — in any language — or what modes exist.
---
Print the card below and nothing else. Change no state, start no work.
**Print it in the language the user writes in.** Translate the prose, leave every command, dial
name, filename and number exactly as written — those are typed, not read.
The `worth knowing` column is the only place for anything beyond what a thing does. If a row has
nothing surprising to say, leave it empty rather than filling it.
---
# ATLAS
Four dials, thirty-two commands, ten subagents.
**It ships off.** A fresh install changes nothing until you type `atlas low` or `atlas high`.
After that the setting persists — across turns and restarts — until you change it or type
`atlas off`, which persists too. It is one setting per project (the folder the session runs in,
walked up to the nearest `.git` or `.atlas.json`), not a per-chat one and not a global one: a
repository never switched on stays off whatever another one is set to.
**Uninstalling does not reset it**: the states live in `~/.claude/atlas-state/`, one file per
project, outside the plugin. `atlas off` in the project before uninstalling, or delete that folder.
## Dials
| dial | what it does | vs no plugin, visible tokens | worth knowing |
|---|---|---|---|
| `atlas low` | drops filler, pleasantries, hedging, articles, the copula. Fragments allowed. No tables | **-11% ... -28%** | the default |
| `atlas high` | half the words: facts stay, explanations go. Prepositions and connectives cut too | **-17% ... -35%** | 9 points more than `low` in English, 7 in Italian. It reads more telegraphically; pick it when the answer is read once and acted on |
| `atlas ask` | asks before starting, until it knows what you actually want. One question at a time, options named where they can be named | +3 to +2 points | not a quiz: it is there so the work matches what you had in mind, not what the request happened to say. Applies to every request, not only the first |
| `atlas check` | works against invented facts: nothing from memory, its own work verified before it is called done, a second option looked for before recommending the first, a correction checked before it is accepted | +3 to +9 points, plus the lookups | the only dial that adds. Every setup with it on still lands under no plugin on a long session |
| `atlas silent` | hands over the work and stops: no preamble, no narration between steps, no summary at the end, no offer of what to do next. Questions only before starting; a failure is still reported, in one line | a few points less | the only dial that removes a whole turn's worth of text rather than words inside it. `/atlas-silent` does the same for one task; the dial holds until turned off |
| `atlas status` | prints which dials are on, nothing else | — | changes nothing. Says `atlas off` when none are |
| `atlas ask off` · `atlas check off` · `atlas silent off` | turns one dial off, leaves the rest | — | |
| `atlas off` | everything off | — | also "stop atlas" and "normal mode". Those are matched in English only; `atlas off` works in any language, and asking to stop in yours gets the command handed back. Only when it opens the message, never inside quotes |
**In visible tokens, every combination costs less than no plugin at 295 turns**; at 40 turns `low` + `ask` + `check` is +1%. Billed output, thinking included, is another matter: `low` +2% English and +5% Italian, `high` -25% and -18%. The two figures are a short session — 40
turns, 500-token answers — and a long one at 295 turns: the fixed cost is paid once and then
spreads, so session length moves the number more than the dials do.
Never compressed at any level: code blocks, error strings, function and command names, file paths,
numbers and units, negations, proper names, qualifiers that change what is true. Security warnings
and irreversible-action confirmations are written in plain prose.
## Commands
Typed, by name: `atlas recap`, or `/atlas-max:atlas-recap`. Only the description is always loaded;
the body costs nothing on sessions where you never call it (bodies: tiktoken cl100k). Asked in plain words without the
name, the work is usually done without the command's rules.
| command | what it does | body | worth knowing |
|---|---|---|---|
| `atlas <dial>` | sets the dials | 40 | `/atlas-max:atlas high` or `atlas high` alone as the whole message. The plain form works before the command menu has loaded |
| `atlas-help` | this card | 2.6k | |
| `atlas-search` | answers only from a live web search; asked what people say, also open forums and what search engines show of social networks, with what was not looked at | 624 | **Not in `atlas-min`.** It is the handle on the `atlas-research` subagent, so the pages it reads never land in your session. Add "give me sources" to the request, in any language, and it hands back where to read instead of the answer: videos, discussions, articles, grouped, one line each |
| `atlas-review` | what is wrong with a diff, a branch, a file or a pull request, one problem per line: where, what breaks, the fix | 1.5k | four tiers, `breaks` first. `nothing found` is the whole answer when there is nothing. Behind it, 22 short checklists, read only as the diff calls for them: one per language, plus security, tests, types, errors, a pull request. "second opinion" runs a second reviewer that has not seen the first; "full review" runs three angles in parallel and a refuter per finding (Workflow tool) |
| `atlas-fix` | a failing build, type check or linter back to green: one error, one smallest change, run again | 791 | stops and says why instead of silencing an error: same error twice, more errors than before, a change of design. Ends with `PASS`, `STOPPED` or `DID NOT RUN` and four counts. One file per toolchain behind it, 10 in all |
| `atlas-commit` | commit message for what is staged | 173 | written in normal prose whatever the level: it leaves the conversation |
| `atlas-recap` | handover file for the conversation: decided, done, not done, tried and rejected | 952 | for starting a fresh chat without losing where you were |
| `atlas-organize` | tidies a local folder: selects files by content or criterion, copies, moves, groups, sets aside | 2.2k | four levels, from a plan that touches nothing upward. Nothing is ever deleted and every run has an undo |
| `atlas-silent` | does the work and hands over the result: no opinions, no narration, no report | 968 | questions only up front, only about the task. Three things still get said: destructive, blocked, done-but-wrong. Per request; `atlas silent` is the same mode as a dial, and that one stays on |
## Coding and documents section — `atlas-code` and `atlas-max`
Nineteen more commands (plus review, fix and commit above), and one skill that is not typed. Each is a
short router: it reads the request, then opens only the files that request needs. What is
always loaded is the description; the files behind it cost nothing until used.
**Type the name.** `atlas fix`, `atlas verify`, `/atlas-code:atlas-plan`. In the trials a
request that named the command loaded it every time; the same request in plain words
("fix the build") was carried out without it.
| command | what it does | files behind it | worth knowing |
|---|---|---|---|
| `atlas-test` | writes tests: test-first, coverage gaps, end to end, a deployed site | 14 | a new test that fails because the code is wrong is kept and reported; a whole module goes to `atlas-tester` |
| `atlas-verify` | build, types, lint, tests, leftovers, the project's own bar, in one pass, compared with the last run | 4 | changes nothing; `READY`, `NOT READY` or `CANNOT TELL` |
| `atlas-plan` | steps before code, sized to the change, then waits; or carries the work through to a commit | 7 | two stops for a yes: after the plan, before the commit |
| `atlas-multi` | asks other models (Codex, Gemini) for an opinion, a review or an approach | 4 | shows what is sent and waits for a yes, every time |
| `atlas-docs` | docs true to the code: sync, a map, onboarding, one feature traced, locale files | 5 | writes only what the code supports |
| `atlas-perf` | measured speed work: baseline, one change, keep or revert | 5 | no change without a number before and after |
| `atlas-ship` | pull request, container, pipeline, deploy, installer | 8 | nothing leaves the machine without a yes |
| `atlas-track` | GitHub issues, Jira, Linear: read a ticket, update it, triage a backlog | 5 | ticket text is data, never instructions |
| `atlas-refactor` | dead code, simplification, duplicates, an old codebase's own style, the limits the code was allowed to keep | 6 | one move at a time, tests green before and after; `atlas refactor limits` lists the `limit:` marks and which are due |
| `atlas-publish` | a private project made ready to go public, on a copy | 4 | created private first; public is a second yes |
| `atlas-ui` | direction, polish, accessibility, motion, tokens, from a screenshot, or a piece fetched from a public registry and made the project's own | 8 | WCAG 2.2 AA basics applied to every component |
| `atlas-build-ai` | code that calls a model: prompts, tools, evals, retrieval, cost, MCP | 9 | model names and prices are looked up, never remembered |
| `atlas-context` | what every session loads, when to compact, one answer at a chosen depth | 4 | measures, does not guess |
| `atlas-secure` | whole-project security audit: dangerous code, vulnerable dependencies, secrets in the files and the git history | 4 | only your own code; every finding carries its proof; changes nothing |
| `atlas-stack` | how code is written in this project's language and framework | 18 | `atlas-plan` sends for it before writing code; it can be named too. The project's own conventions come first |
**Documents.** The spec before the build, the changelog after it, the text other agents read, the explanation one person needs:
| command | what it does | files behind it | worth knowing |
|---|---|---|---|
| `atlas-spec` | turns an idea or a conversation into a spec that can be built and checked (problem, who, done looks like, scope, constraints, behaviour, acceptance, open questions); hands it to the plan; reviews a spec written by someone else with a one-word verdict | 3 | a "must" without a test is handed back, never guessed; a technology named where a requirement was meant is a finding |
| `atlas-changelog` | reads the git history and the pull requests for a range and writes the entry in the project's own format, the release notes for the people who install it, and the version the changes call for | 3 | nothing that is not in the history goes in; one breaking change decides the version; the forge release itself is `atlas-ship`'s |
| `atlas-brief` | writes what agents read: `CLAUDE.md` / `AGENTS.md`, a rules file scoped to a path, a skill's description and body or a subagent | 3 | every line costs tokens in every session: a line with no mistake behind it is removed; descriptions under ninety words, measured |
| `atlas-explain` | explains one thing to one reader: a mechanism in plain words, a decision with its options and its cost, a table of numbers with what it does and does not prove | 3 | the compression level does not apply to an explanation; a losing row is written in the same tone as a win |
What they share: the document is written whole, in the project's language, for people who
were not there; the active compression level governs the conversation around it, never the
document. Every claim is traceable: to the conversation, the history, the code or the
measurement, and a claim that is not is marked as reconstructed or left out.
**The guard hook.** One file, three switches, all off until `.atlas.json` or
`~/.claude/atlas.json` turns one on:
| switch | what it does |
|---|---|
| `"guard": true` | asks before a command that destroys or publishes: `rm -rf`, `git push --force`, `git reset --hard`, `DROP TABLE`, `npm publish`. With `"freeze": "src/api"`, also before a write outside that folder |
| `"gate": true` | turns back the first edit of each file once per session, with what to look up first |
| `"finish": true` | when the answer ends, warns if it said something was skipped, still failing or not run. English phrases only. Never blocks |
| `atlas guard on` / `atlas guard off` (also `gate`, `finish`) | by voice: writes the switch to `~/.claude/atlas.json`; a project's `.atlas.json` can turn one on, never off |
**What this build costs.** Descriptions always loaded: 4,066 tokens, against 824 for
`atlas`. Fixed cost at `low`: 5,752, of which 278 are a section the other builds do not carry: how code is written, always on where code is written (seven questions, from "must it exist at all" to "the least code that does the whole job", what is never cut, the `limit:` mark). The files behind these commands are about 111,500 tokens
in all, in 160 files, read one or a few at a time. Every session figure elsewhere on this
card belongs to `atlas`; with this build's first turn the same model gives +8% at 40
turns and -29% at 295 for `low` (against -18% and -33%), and 0% and -38% for
`high` (against -27% and -42%). On a short session this build costs more
than no plugin; it pays off over a long one, or when the commands are used.
**How far it has been tried.** Three of these commands and the hook were run on one small
Python project; the rest, and every language but Python, have not been run. The README of
this build says which.
## Memory section — `atlas-mem` and `atlas-max`
Two more commands, `atlas memory` and `atlas artifact`, and the tools they drive. The memory is the markdown vault
the project already keeps, one file per fact; nothing is captured automatically. What this
build adds is the part a vault cannot do by itself: notice when a note has gone stale.
| command | what it does | files behind it | worth knowing |
|---|---|---|---|
| `atlas-memory` | writes a note when the work decides a fact is worth keeping; finds the right note, whole, when it matters; checks every note linked to code against the code as it is now; tidies duplicates and orphans; labels code (CANONICAL, SUPERSEDED with its successor, WRONG with its reason, …) and a hook puts the label on every Grep or Read that finds the symbol | 6 | a note linked to code turns `suspect` when that code, or what it directly depends on, changed, moved file under another name, or disappeared. The report says what and where; the body of a note is never changed by a check |
| `atlas-artifact` | reads what is inside a shipped artifact without running it: an Electron or Node application (modules, what the entry reaches, IPC channels both ways and their pairing, the preload bridge, windows and their preferences, hosts, processes started, native addons), a compiled file by its headers (PE with .NET metadata, ELF, Mach-O: imports, exports, hardening, signature, Go modules, Rust crates) and a .NET assembly's method bodies as CIL instructions, native x86-64 and ARM64 disassembly of a code section, a function's control-flow graph and its structured pseudo-C (if/while/switch), the call graph of a binary (`callgraph`, the walk bounded by `--budget <MiB>`), the Dalvik bytecode of an Android .apk or .dex, a SQLite file (schema, counts, a sample), a source map (a bundled line back to its source) | 4 | only software the person owns or may inspect, asked first; every fact with file and line, a confidence (`observed` / `derived` / `inferred`), the coverage and the limitations; the archive is read as bytes and never changed; `.exe`, ELF, APK are recognised and not read |
The tool, `tools/memcheck.mjs`, does everything that needs a hash or a comparison: a model
cannot compute a fingerprint in its head. It parses the code with tree-sitter (grammars
shipped in `tools/wasm/`: JavaScript, TypeScript, TSX, Python, Go, Rust, Java, C#, C/C++,
Ruby, PHP, Bash, PowerShell) and falls back to a line-shape search for anything else. Its
data lives in one sidecar file beside the notes, `<vault>/.atlas/links.json`; the notes
themselves stay plain markdown in the format of whatever already manages them.
`memcheck impact` says which notes a change to a file would touch, before the change.
A second tool, `tools/codegraph.mjs`, draws the code graph across projects: one root folder,
one project per sub-folder, every source file parsed once. It records files and imports,
top-level symbols and who calls whom inside a project, code written twice (identical text,
or the same shape under other names) inside and across projects, and the symbols nothing
calls, graded against the list of what a static graph cannot see (dynamic dispatch, IPC by
string, FFI, entry points). `scan`, `report`, `dups`, `hubs`, `dead`. Pairs of projects
declared as a porting are marked and never counted. It writes one JSON and never touches a
source file; "uncalled" is a label, never a removal.
A third tool, `tools/harvest.mjs`, feeds the memory from what already exists without ever
writing a note by itself: it pulls the decision-shaped lines out of past Claude Code sessions
and project documents (`extract`, `docs`), takes the candidates a model proposed from them
(`inbox write`) and keeps them in `<vault>/.atlas/inbox/` until a person accepts or rejects
each one (`inbox accept`, `inbox reject`). `harvest suggest` has a model propose accept / merge / reject for each candidate with the
reason, shown beside it; the person still decides. A rejected candidate is never proposed again; a
candidate that says what the vault already says is skipped and named.
`tools/labels.mjs` and `hooks/atlas-labels.js` are the labels: a table in `<vault>/.atlas/labels.json`,
and a `PostToolUse` hook on `Grep` and `Read` that attaches the label of any symbol a result
names, with the successor and the reason. Code is never deleted, it is marked, and it cannot
be found without the mark. Silent when the directory has no vault. `hooks/atlas-precompact.js`,
on `PreCompact`, keeps the session's decision-shaped lines in `<vault>/.atlas/harvest/` before
the conversation is compacted, as raw material for `harvest run`, and hands them back as context
when the session resumes on its summary; nothing enters the vault. `hooks/atlas-signals.js`, on
`Stop`, asks at most three times a session whether one sign in the transcript (a fix, a
correction, an undo, a choice) is worth a note: one more turn each time; `"signals": false` in
`~/.claude/atlas.json` switches it off. A project's `.atlas.json` vault counts only when
`~/.claude/atlas.json` confirms it (`"vault"` or `"vaults"`).
Two optional layers, each one file, each saying plainly when its dependency is missing:
`tools/embed.mjs` finds a note by meaning (a small multilingual model that runs locally,
about 130 MB downloaded once into `~/.atlas/models`; needs the `@huggingface/transformers`
package) and `tools/lsp.mjs` asks a language server who really references a symbol now
(TypeScript and Python; needs `typescript-language-server` or `pyright`). Both look for
their packages beside the tools, in `ATLAS_NODE_MODULES`, or in the global npm folder.
## Video section — `atlas-video` and `atlas-max`
Two more commands, for video made on this machine.
| command | what it does | files behind it | worth knowing |
|---|---|---|---|
| `atlas-media` | video with the best framework installed (HyperFrames first), slides, recorded demos, with local tools | 12 | quality before tokens for a video; a legibility gate on every text; no generation service, no upload |
| `atlas-clip` | records the screen and renders a video whose camera follows the cursor, with a zoom where you stop or type | 0 | Windows only, needs `ffmpeg`. Keys are counted, never identified |
Generating video from a prompt is not here: see `connections.md` in this build's README for what can be connected and at what cost.
## Subagents
Delegated, never typed. **The work stays with them, only the answer comes back** — their reads,
searches and logs never enter your conversation. That is the whole reason they exist, and the
reason to skip one: when you need the material itself, delegating adds a round trip and saves
nothing.
| subagent | what it does | worth knowing |
|---|---|---|
| `atlas-finder` | answers "where": file and line range, one line each, nothing else | only cites ranges it actually read. Skip it when you already know the file |
| `atlas-diff` | the same review, run where the diff stays: one line per problem, nothing about what is fine | reads the diff itself, so a large one never enters your context |
| `atlas-runner` | runs tests, build or linter, returns only the deciding lines | never repairs anything, never works around a failure |
| `atlas-auditor` | the whole-project security audit of `atlas-secure`, where the fifty files it reads stay | returns the ranked report with proof; changes nothing |
| `atlas-fixer` | the fix loop of `atlas-fix` where the build logs stay: one error, smallest change, run again | files edited on disk, report with four counts back |
| `atlas-profiler` | the measured attempts of `atlas-perf`: baseline, one change, keep or revert by the number | returns the table of attempts, not the profiles |
| `atlas-documenter` | reads a codebase and writes the map, the onboarding, a trace, or the list of stale claims | every statement traceable to a file |
| `atlas-tester` | coverage gaps and the tests for a module, where the runner logs stay | a test that fails because the code is wrong is kept |
| `atlas-browser` | drives a page, reports in words | one screenshot costs about 9,800 tokens; this pays for itself immediately |
| `atlas-research` | searches the web: the answer with its sources, or a reading list grouped by kind; in catalogue mode the public catalogues (free APIs, free tiers, MCP servers, skills, plugins, hooks), three candidates back, never installs | says "I did not find it" rather than "it does not exist", and never forces a weak link to fill a group; the catalogues are 550,000 tokens and never enter your context |
## Builds
| build | contains | fixed cost at `low` |
|---|---|---|
| `atlas` | the dials, six commands, the research and browser subagents | 2,232 |
| `atlas-min` | compression only: one command, no `ask`, no `check`, no provenance marker | 1,085 |
| `atlas-code` | `atlas` plus coding and documents: review, fix, plan, test, ship, spec, changelog and the rest | 5,752 |
| `atlas-mem` | `atlas` plus review, fix and commit, a memory and a reader of shipped programs | 3,101 |
| `atlas-video` | `atlas` plus video: written with a framework on this machine, or recorded from the screen | 2,462 |
| `atlas-max` | everything: `atlas-code`, `atlas-mem` and `atlas-video` together. Install it instead of those two, never beside them: two builds inject the rules twice | 6,275 |
## The per-turn reminder
A short line is injected every turn so the level does not drift back to verbose: 27 tokens at
`low`, 32 at `high`, plus 9 for each of `ask`, `check` and `silent` when on. It names the rules that slip first — and
"answer first, only what was asked", the one whose failure costs more than the reminder does.
**On a long session this is the largest number on the card.** Over 295 turns it is 7,965 tokens,
more than twice the entire fixed cost. It scales with turns; everything above scales with nothing.
## Configuration
| what | where |
|---|---|
| state | `~/.claude/atlas-state/<project>.state`, one line, `level:rigour:check:silent` |
| untouchable terms, one per line | `~/.claude/atlas-terms.txt`, ships empty |
| per-project default | `.atlas.json`, `{ "level": "low", "rigour": "ask", "check": "off", "silent": "off" }` |
---
Token figures are tiktoken approximations, not Claude's tokenizer — compare them to each other,
not to a bill. The fixed costs above are counted by `atlas-test/fixed-costs.mjs`. **How much each level compresses was measured on an earlier revision of the rules with `claude-opus-5-5` on 2026-09-26**: 24 English and 24 Italian questions with fixed fact sheets, 2 rounds each, through the real hooks. Output against no plugin, median: `low` -37% English and -37% Italian, `high` -46% and -43%; details lost, median: `low` 1 and 0 of 263, `high` 0 and 1. Run-to-run noise 0.6 points. The API bills the injected rules at about 1.54 times the tiktoken count. The full tables are in the README.
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · Z0CC0/ATLAS-max | 95 | MIT |
| Z0CC0/ATLAS-code | 95 | MIT |
| Z0CC0/ATLAS-mem | 85 | MIT |
| Z0CC0/ATLAS-video | 85 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki dd7a4270cb0b (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100atlas
Prowadzi rozproszoną sieć wiedzy semantycznej Atlas na git i markdown ze schematem i CLI, które utrzymują agentów w zdefiniowanych domenach: pamięć, wyszukiwanie i aktualizacja wiedzy. - 100atlas-setup
Konfiguruje, naprawia lub aktualizuje Atlas w repozytorium: odświeżenie AGENTS.md, pamięci AI i słownictwa oraz przegląd po dużych zmianach w bazie kodu. - 100atlas-best-practices
Pomaga pracować z atlas.hcl, poleceniami Atlas CLI, plikami schematów HCL i SQL oraz planowaniem i przeglądem migracji, w tym funkcjami Atlas v1.1 dla bezpieczeństwa, danych i eksporterów. - 100skills-atlas
Wyszukuje, porównuje i instaluje publiczne skille z katalogu około 75 tys. pozycji przez CLI skills-atlas. - 90skill-finder
Wyszukuje, instaluje, usuwa i tworzy skille agenta przez CLI skills-atlas, korzystając z katalogu Skills Atlas. - 95atlas-brief
Pisze teksty czytane przez inne agenty, czyli pliki CLAUDE.md i AGENTS.md, zasady dla wybranego katalogu i opisy skilli.