Agent skill

Documentation

by home-operations in home-operations/kopiur

How Kopiur writes and maintains user-facing docs — the MkDocs Material site under docs/ and the example manifests under deploy/examples/.

AGPL-3.0Auto-check passedDevOps & Cloud

Install Documentation

skills CLI
$ npx skills add home-operations/kopiur --skill documentation -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install home-operations/kopiur documentation --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/home-operations/kopiur.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/documentation .claude/skills/documentation && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
documentation
GitHub stars
113
Token cost
~2.5k tokens
SKILL.md length
737 words
Files
1
Skills in repo
3
Repo updated
First seen
Licence
AGPL-3.0

At a glance

How Kopiur writes and maintains user-facing docs — the MkDocs Material site under docs/ and the example manifests under deploy/examples/.

  • Works in 3 steps: Deploy — how to install / apply this… → Use — the mental model first. Kopiur… → Modify common values — call out the…
  • Editing any doc page
  • SKILL.md covers The bar: painfully clear for…, Examples are the backbone… and Common mistakes
  • Calls mise and kubectl; needs KOPIA_PASSWORD

What it does

Documentation is an agent skill from home-operations/kopiur. How Kopiur writes and maintains user-facing docs — the MkDocs Material site under docs/ and the example manifests under deploy/examples/. Use when adding or editing any doc page, writing or changing an example manifest, or whenever you change operator behavior that affects how someone deploys, uses, or configures Kopiur (CRD fields, defaults, Helm values, RBAC, reconciler UX, kopia/mover invocation). Encodes the painfully-clear-for-three-audiences rule, the…

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in DevOps & Cloud, covering Container orchestration and Authorization and RBAC. It works with Kubernetes. The repository describes itself as: A Kopia-native Kubernetes backup operator written in Rust. The licence is AGPL-3.0.

When your agent uses it

  • Editing any doc page
  • Changing an example manifest
  • Whenever you change operator behavior that affects how someone deploys
  • Configures Kopiur (CRD fields

Example prompts

  • “/documentation”

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. Deploy — how to install / apply this (Helm value, kubectl apply, scope,
  2. Use — the mental model first. Kopiur separates the recipe
  3. Modify common values — call out the handful of fields a real user

What it can do on your machine

Read from SKILL.md and the folder at commit 379efb7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • mise
    • kubectl

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use kubectl, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • KOPIA_PASSWORD

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Documentation loads about 2.5k tokens when it runs. Until then it costs about 157 tokens; SKILL.md has 737 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~157
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from home-operations/kopiur at commit 379efb7, republished under its AGPL-3.0 licence (© home-operations). 737 words, ~2,539 tokens.

Download SKILL.mdSave it as .claude/skills/documentation/SKILL.md (or your agent's skills folder).
name
documentation
description
How Kopiur writes and maintains user-facing docs — the MkDocs Material site under docs/ and the example manifests under deploy/examples/. Use when adding or editing any doc page, writing or changing an example manifest, or whenever you change operator behavior that affects how someone deploys, uses, or configures Kopiur (CRD fields, defaults, Helm values, RBAC, reconciler UX, kopia/mover invocation). Encodes the painfully-clear-for-three-audiences rule, the examples-live-in-deploy/examples-and-are-snippet-included convention, the simple→complex example ladder, and the docs-change-with-the-code discipline.

Kopiur documentation norms

Kopiur's docs are an MkDocs Material site whose source IS the docs/ tree (mkdocs.yml sets docs_dir: docs). Page order and grouping live in the nav: block of mkdocs.yml — there is no SUMMARY.md; a docs/*.md left out of nav: still builds but is unlinked (and --strict warns). Example manifests live in deploy/examples/ and are pulled into the prose at build time (pymdownx snippets); they are never copy-pasted into .md files. mise run docs builds the site with mkdocs build --strict — a broken cross-link or a missing nav file fails the build, so it doubles as our doc lint.

The MkDocs + Material + pymdown-extensions toolchain is pinned in pyproject.toml / uv.lock and run via uv (mise installs uv). Material bundles mermaid.js and the admonition styling, so there are no preprocessor binaries or committed assets.

The bar: painfully clear for three audiences

Every user-facing page must let a reader who has never seen Kopiur succeed at all three of:

  1. Deploy — how to install / apply this (Helm value, kubectl apply, scope, prerequisites). No "obviously you'd…" steps left implicit.
  2. Use — the mental model first. Kopiur separates the recipe (SnapshotPolicy) from the invocation (Snapshot) from the schedule (SnapshotSchedule); say which one does what before showing fields.
  3. Modify common values — call out the handful of fields a real user actually changes (bucket/prefix/endpoint, secret names, cron + jitter, retention, identity, deletionPolicy) and what each does. Don't make readers reverse-engineer the CRD to find the knobs.

When in doubt, over-explain the "why", and prefer a worked example over a prose description. Use Material admonitions for the gotchas — alpha API, webhook-enforced constraints, version prerequisites. This repo uses the pymdownx blocks form (/// note | Title … ///), NOT the classic !!! note form: the classic admonition extension is not even registered (mkdocs.yml wires up pymdownx.blocks.admonition), because the pre-commit oxfmt pass strips the 4-space body indentation !!! requires and silently breaks every such block. The blocks body stays at column 0 and the block is closed with a /// line:

markdown
/// warning | Lose the password, lose the backups

The `KOPIA_PASSWORD` encrypts the repository. If you lose it, the backups are
unrecoverable — kopia cannot decrypt without it.

///

Keep a blank line before the closing /// (so oxfmt doesn't fold it into a preceding list item). The title is bare text after | — not quoted. Registered types are the canonical Material set: note, abstract, info, tip, success, question, warning, failure, danger, bug, example, quote — important is not one; use warning for a webhook-enforced constraint.

Examples are the backbone (simple → complex)

Reach for an example for any non-trivial capability. The example set must form a ladder: the lowest-numbered examples are the canonical first run with the fewest moving parts; later ones layer in complexity (cluster scope, selectors, GitOps deploy-or-restore, discovered snapshots, fine-grained maintenance). Add new examples at the complexity tier they belong to, not just at the end.

Show full SKILL.md (295 more words)Show less
The hard rule: example YAML lives in deploy/examples/, never inline

Docs include manifests with a pymdownx snippet marker so prose and apply-ready files cannot drift. The snippet path is repo-root-relative (snippets base_path is the repo root):

markdown
## Example 09 — <what it demonstrates>

<1–3 sentences: what this shows and when you'd reach for it.>

```yaml
--8<-- "deploy/examples/09-<kebab-name>.yaml"
```

**Never** paste a literal multi-line manifest into a `.md` file. If you're about
to, stop and make it a file under `deploy/examples/` instead. (Short inline
`console`/`kubectl` snippets that aren't manifests are fine.)

### Example manifest conventions (match the existing files)

- Filename `NN-kebab-name.yaml`, `NN` zero-padded and ordered by complexity.
- A top-of-file comment block: what it demonstrates, the CRD type/field it maps
  to (verified against `crates/api`), and any caveats on field shapes.
- `REPLACE_ME` for secrets the user must supply; a real-looking but obviously-
  placeholder value otherwise.
- Inline comments on every non-obvious field — especially the "common values"
  above and any default being made explicit for teaching.
- Backends are **externally tagged** (`backend.s3`, not `backend: { kind: S3 }`)
  — see [[kopiur-design]]. Apply-ready and self-contained (Secret + CRs in one
  file) so `kubectl apply -f` just works after filling in `REPLACE_ME`.

### Adding an example: which of the two homes it belongs to

There are **two** conventions, and the number tells you which:

**01–20 — the `docs/examples.md` ladder.** A three-touch change:

1. Create `deploy/examples/NN-name.yaml`.
2. Add a `## Example NN — …` section in `docs/examples.md` with the
   `--8<-- "deploy/examples/NN-name.yaml"` snippet inside a `yaml` fence.
3. Add a row to the table at the top of `docs/examples.md`.

**21+ — capability-page inclusion.** The ladder is a *tutorial* sequence and
stops at 20 deliberately; everything after it is a per-capability example that
belongs beside the prose explaining that capability, not at the end of a
tutorial. So a two-touch change:

1. Create `deploy/examples/NN-name.yaml`, usually with
   `# --8<-- [start:…]` / `[end:…]` section markers so the page can pull just
   the CR that teaches the point.
2. Snippet-include it from the capability page that documents the field
   (`docs/replication.md` for 19's replication CR, `docs/repositories.md` for
   the `spec.seed` examples, `docs/backends/s3.md` for 38, …).

   **Do not** add a `docs/examples.md` row/section for a 21+ example — that is
   how the same manifest ends up documented twice and the two copies drift.

Either way the file must be reachable from *some* page: an example nothing
includes is an orphan, and nothing in the build catches it.

**Scenario bundles** are a third home: `deploy/examples/scenarios/NN-name.yaml`,
one per `docs/scenarios/*.md` page, pulled by that page (whole-file or by
section) and listed in the scenarios index table. They are typed-checked by
`crates/api/tests/examples_match_crd_shapes.rs` like everything else.

A new top-level **page** (not an example) also needs an entry in the `nav:` of
`mkdocs.yml`, or it builds unlinked (and `--strict` warns). A new **scenario**
page additionally needs its row in `docs/scenarios/index.md`.

## Docs change in the same PR as the behavior

**Whenever you change logic that affects how someone deploys, uses, or configures
Kopiur, update the docs in the same change.** This is not a follow-up task.

Triggers that REQUIRE a docs/examples update:

| You changed… | Update… |
|---|---|
| A CRD field / shape / default in `crates/api` | the relevant `docs/*.md` prose **and** any example manifest that uses it |
| A Helm value or install scope (`deploy/helm`) | `docs/install.md` |
| RBAC / SA / mover behavior | `docs/movers.md` |
| Maintenance defaults or projection | `docs/maintenance.md` |
| A webhook-enforced constraint | the affected page (state it as a `/// warning` admonition) + the example that would otherwise violate it |
| A reconciler UX change (status, print columns, phases) | wherever that surface is described |

Field shapes shown in docs/examples must be the real ones — the manifests are
apply-ready, so a wrong field is a user-facing bug, not a typo.

## Verify before claiming done

```bash
mise run docs   # mkdocs build --strict (broken link / missing nav file = build fail)

The build also expands every snippet — a renamed/missing example file fails here (snippets check_paths is on). --strict additionally validates heading anchors, so a deep-link to a #section that no longer exists fails too. Don't claim a docs change is done without a green mise run docs. For a fast inner loop without the rustdoc nesting, use mise run docs-serve (live-reload mkdocs serve). If you added/changed a manifest, the field shapes should be the same ones the tests in crates/api accept (see [[kopiur-design]] for the from_yaml parse path); a manifest that wouldn't survive admission is wrong even if the site builds.

Common mistakes

  • Pasting YAML inline in a .md instead of snippet-including a file → drift.
  • Adding a 01–20 ladder example but forgetting the docs/examples.md table row or the section (or vice-versa) → orphaned file or dead reference.
  • Adding a 21+ example to the docs/examples.md ladder as well as its capability page → the same manifest documented twice, and the copies drift.
  • New page not added to the nav: in mkdocs.yml → builds unlinked.
  • Writing an admonition in the classic !!! note form (4-space-indented body) instead of the /// note | Title … /// blocks form → the title renders as literal text and the indented body becomes a code block (it does not error — eyeball the rendered page or grep the built HTML for class="admonition).
  • Documenting the field list without the mental model or the "which values do I actually change" guidance → technically complete, practically useless.
  • Shipping a behavior change with "docs later" → the docs now lie. Same PR.
  • Internally-tagged backend in an example → won't admit; contradicts the CRDs.

© home-operations, AGPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/documentation of home-operations/kopiur.

Open the folder on GitHubat commit 379efb7

Compare with similar skills

Documentation next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Documentation compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Documentation this skillhome-operations/kopiur113—~2.5kAutomated safety check: PassAGPL-3.0
KubeSphere Multi-Tenant Managementkubesphere/kubesphere17k1 repos~3.1kAutomated safety check: PassCustom licence
Kubernetes SpecialistJeffallan/claude-skills12k1 repos~2.1kAutomated safety check: PassMIT
Kubernetes Patternstimothywarner-org/claude-code224—~4.5kAutomated safety check: PassMIT
Azure Bastion Jitvinayaklatthe/microsoft-security-skills175—~2.2kAutomated safety check: PassMIT
Kubernetes Patternsaffaan-m/ECC275k1 repos~5kAutomated safety check: PassMIT

Similar skills

  • Creates and queries KubeSphere users, workspaces and projects and assigns built-in roles, defaulting to least privilege and never deleting anything.

    17k GitHub starsUsed in 1 repo~3.1k tokens
    DevOps & CloudAuto-check passed
  • Kubernetes Specialist

    Jeffallan/claude-skills

    Creates and checks Kubernetes manifests, Helm charts, RBAC and network policies, and helps debug pod problems, with kubectl checks and rollback steps.

    12k GitHub starsUsed in 1 repo~2.1k tokens
    DevOps & CloudAuto-check passed
  • Kubernetes Patterns

    timothywarner-org/claude-code

    Kubernetes workload patterns, resource management, RBAC, probes, autoscaling, ConfigMap/Secret handling, and kubectl debugging for production-grade deployments.

    224 GitHub stars~4.5k tokensUpdated 2 mo ago
    DevOps & CloudAuto-check passed
  • Azure Bastion Jit

    vinayaklatthe/microsoft-security-skills

    Guidance for secure remote VM management in Azure using Azure Bastion combined with Defender for Cloud just-in-time (JIT) VM access.

    175 GitHub stars~2.2k tokensUpdated 3 mo ago
    DevOps & CloudAuto-check passed
  • Kubernetes workload patterns, resource management, RBAC, probes, autoscaling, ConfigMap/Secret handling, and kubectl debugging for production-grade deployments.

    275k GitHub starsUsed in 1 repo~5k tokens
    DevOps & CloudAuto-check passed
  • Performing Kubernetes Etcd Security Assessment

    mukul975/Anthropic-Cybersecurity-Skills

    Assesses the security posture of the etcd cluster backing Kubernetes: encryption at rest, TLS peer and client transport, access control, backup encryption, and network isolation.

    34k GitHub stars~1.9k tokensUpdated 1 mo ago
    DevOps & CloudAuto-check passed

More from home-operations/kopiur

  • Error Handling And E2E

    home-operations/kopiur

    How Kopiur does strongly-typed, actionable error handling and end-to-end testing.

    113 GitHub stars~2.7k tokensUpdated today
    Auto-check passed
  • Kopiur Design

    home-operations/kopiur

    Design norms and locked decisions for the Kopiur Kopia-native Kubernetes backup operator (Rust/kube-rs).

    113 GitHub stars~2.4k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Documentation

What does Documentation do?

How Kopiur writes and maintains user-facing docs — the MkDocs Material site under docs/ and the example manifests under deploy/examples/. Documentation is an agent skill from home-operations/kopiur. How Kopiur writes and maintains user-facing docs — the MkDocs Material site under docs/ and the example manifests under deploy/examples/.

When should I use Documentation?

Documentation fits situations like: editing any doc page; changing an example manifest; whenever you change operator behavior that affects how someone deploys; configures Kopiur (CRD fields.

How do I install Documentation in Claude Code?

Run `npx skills add home-operations/kopiur --skill documentation -a claude-code`. Or copy the skill folder (.claude/skills/documentation in home-operations/kopiur) into .claude/skills/documentation in your project. Claude Code loads it when a task matches its description.

How do I install Documentation in Codex?

Run `npx skills add home-operations/kopiur --skill documentation -a codex`. Or copy the skill folder (.claude/skills/documentation in home-operations/kopiur) into .agents/skills/documentation in your project. Codex loads it when a task matches its description.

Can I use Documentation in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add home-operations/kopiur --skill documentation -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/documentation, .gemini/skills/documentation, .github/skills/documentation and .opencode/skills/documentation in your project.

What does Documentation need to run?

Going by SKILL.md and its folder, Documentation needs the command-line tools its instructions call (mise and kubectl) and credentials named KOPIA_PASSWORD.

Does Documentation access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Documentation safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Documentation use?

Documentation is published under the AGPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Documentation use?

About 2.5k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Documentation?

Skills that share tags, products or a category with Documentation: KubeSphere Multi-Tenant Management (kubesphere/kubesphere, 17k stars), Kubernetes Specialist (Jeffallan/claude-skills, 12k stars), Kubernetes Patterns (timothywarner-org/claude-code, 224 stars) and Azure Bastion Jit (vinayaklatthe/microsoft-security-skills, 175 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Documentation?

home-operations (a GitHub organization) maintains it in home-operations/kopiur, which has 113 GitHub stars. The repository holds 3 skills in this directory. The repository was last updated on October 8, 2026.

Source: home-operations/kopiur on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.