--- name: skill.cc description: Root namespace for agent capabilities. Reading IS installing. The skill distribution platform. --- # skill.cc > **The root namespace for agent capabilities.** > Reading this is installing it. --- ## What This Is skill.cc is a skill distribution platform. Point any agent here, it learns capabilities. ``` skill.cc/[name] → Read SKILL.md → Capability acquired ``` The docs ARE the installer. The directory IS the product. --- ## Architecture ``` ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ LOCAL │ │ │ │ ~/cc/skill.cc/ CANONICAL source │ │ │ Human browses here │ │ │ │ │ │ NTFS junction │ │ │ │ │ ~/cc/.claude/skills/ Claude Code reads here │ │ │ Discovers at startup │ │ │ (metadata only — 100 tok/skill) │ │ │ Full SKILL.md on invocation │ │ │ │ │ WEB │ │ │ │ ~/cc/skill.cc/ │ │ │ │ │ │ publish step │ │ │ │ │ https://skill.cc/ World reads here │ │ │ │ │ │ WebFetch / curl │ │ │ │ │ ANY AGENT "reading IS installing" │ │ │ └─────────────────────────────────────────────────────────────────────┘ ``` --- ## Installed Skills ### Infrastructure | Skill | What It Does | |-------|--------------| | `skill.cc/gemini` | UX design consultation + image generation | | `skill.cc/cvfs` | Semantic search across 261k documents (Chroma) | | `skill.cc/pylons` | Context coherence infrastructure (PLLs for memory) | | `skill.cc/skillcraft` | Meta-skill: create new skills ("reading IS installing") | | `skill.cc/skillify` | Detect latent skill demand, propose new skills | ### Integration | Skill | What It Does | |-------|--------------| | `skill.cc/bluesky` | Post, thread, cross-post, discourse monitoring | | `skill.cc/cloudflare` | Pages deployment, custom domains, DNS | | `skill.cc/namecheap` | Domain DNS management via API | | `skill.cc/look` | Visual perception through Insta360 Link camera | | `skill.cc/lisa` | Deep reading annotator for corpus analysis | ### Knowledge | Skill | What It Does | |-------|--------------| | `skill.cc/cartography` | ASCII maps as information architecture | | `skill.cc/hypercontext` | Spatial context awareness — renders session state as ASCII map | | `skill.cc/lookup` | Visual encyclopedia via Gemini vision | | `skill.cc/briefing` | Morning world check: news + discourse + silence watch | | `skill.cc/intelligenceagency` | AI compliance testing against documented evidence | ### Operations | Skill | What It Does | |-------|--------------| | `skill.cc/migrate` | Monorepo migration, NTFS junctions, path verification | | `skill.cc/compost` | Structured deprecation — study, archive, extract nutrients, clean up dead infra | | `skill.cc/pdf` | PDF reading and analysis | | `skill.cc/webmaster` | Cloudflare analytics — traffic, geo, status, cache, bots (255 zones) | --- ## How To Use **As an agent:** ``` Fetch skill.cc/[name]/SKILL.md → Follow its instructions → Done ``` **As a human:** ``` Tell your agent: "use skill.cc/memory" or "get skill.cc/eyes" ``` **As a developer:** ``` Create skill.cc/[yourskill]/SKILL.md → Your skill is now addressable ``` **Install locally:** ```bash # Clone into your .claude/skills/ or create a junction: mklink /J ".claude\skills" "skill.cc" ``` --- ## The Recursion This file you're reading? It's `skill.cc/SKILL.md`. By reading it, you've installed the meta-skill: **knowing how to find and install any skill.** Point at `skill.cc/[anything]` → Get that thing's SKILL.md → You have it. --- ## Philosophy 1. **Reading IS installing** — No separate install step 2. **URL = API = Docs** — One address, all purposes 3. **Human language = Machine language** — "give it eyes" → `skill.cc/eyes` 4. **Recursive by design** — Skills can mount other skills 5. **Directory = Domain** — `ls skill.cc/` mirrors `https://skill.cc/` 6. **Junction not duplication** — One source, multiple views, zero drift --- ## Lineage - 1945: Vannevar Bush imagines the memex - 1963: Ivan Sutherland creates Sketchpad - 2010: Patrick Collison jokes about /dev/payments - 2026: skill.cc becomes /dev/capabilities --- ## FAQ: How Does This Actually Work? ### How does Claude Code find skills? At startup, Claude Code scans `.claude/skills/*/SKILL.md` and reads the YAML frontmatter (name + description). That's ~100 tokens per skill. The full markdown body only loads when you invoke the skill. ``` ┌──────────────────────────────────────────────────────────────┐ │ LEVEL 1: METADATA Always at startup │ │ ┌──────────────────┐ ~100 tokens per skill │ │ │ name: gemini │ Injected into Skill tool def │ │ │ description: ... │ │ │ └──────────────────┘ │ │ │ on invocation │ │ ▼ │ │ LEVEL 2: FULL BODY On /invoke or auto-match │ │ ┌──────────────────┐ <5,000 tokens │ │ │ # Gemini │ Full SKILL.md markdown │ │ │ ## Quick Commands│ │ │ │ ## How It Works │ │ │ └──────────────────┘ │ │ │ on reference │ │ ▼ │ │ LEVEL 3: RESOURCES On-demand during execution │ │ ┌──────────────────┐ Scripts, templates, assets │ │ │ scripts/post.py │ │ │ │ templates/ │ │ │ └──────────────────┘ │ └──────────────────────────────────────────────────────────────┘ ``` ### What's the 15,000 character budget? All skill descriptions combined must fit in 15,000 characters at startup. If exceeded, skills are **silently dropped**. Check with `/context`. Raise it with: ```bash SLASH_COMMAND_TOOL_CHAR_BUDGET=30000 claude ``` ### Why does skill.cc/ live at the project root instead of .claude/skills/? `.claude/` is a dotfile — hidden by convention, hostile to human browsing. Skills are the product. They should be visible. So `skill.cc/` is the canonical source at the project root, and `.claude/skills` is an NTFS junction pointing at it. ``` ~/cc/skill.cc/ ← you browse here (canonical) ~/cc/.claude/skills/ ← Claude Code reads here (junction) same directory, two paths ``` ### What's an NTFS junction and why not a symlink? A junction is a Windows filesystem pointer. Unlike symlinks, junctions: - Work from WSL2, Windows, AND Node.js (Claude Code) - Require NO admin privileges - Have zero maintenance — they're a pointer, not a copy WSL2 symlinks (ln -s) **do not work** from Windows or Node.js. This was empirically verified, not assumed. ```bash # Create a junction (from WSL2): /mnt/c/WINDOWS/system32/cmd.exe /c \ "mklink /J C:\Users\you\project\.claude\skills C:\Users\you\project\skill.cc" ``` ### What's a SKILL.md file? A markdown file with YAML frontmatter. That's it. ```markdown --- name: myskill description: One line about what this enables. --- # myskill ## Quick Commands | Command | Description | |---------|-------------| | `/myskill do` | Does the thing | ## How It Works Explain the mechanism. ``` Put it in `skill.cc/myskill/SKILL.md`. Claude Code discovers it at next startup. No build step. No registration. Reading IS installing. ### How do external agents install skills from skill.cc? ``` WebFetch("https://skill.cc/memory/SKILL.md") → Agent reads the markdown → Agent now has the capability ``` Or tell your agent in natural language: ``` "Use skill.cc/memory to remember this." ``` The URL IS the API. The docs ARE the installer. ### What's the startup loading order? ``` 1. System prompt ~2,000 tokens 2. CLAUDE.md files (hierarchical) ├── ~/.claude/CLAUDE.md user memory ├── .claude/CLAUDE.md project memory └── .claude/rules/*.md project rules 3. Skill metadata (name + desc only) ~100 tok/skill 4. Settings & permissions 5. MCP server configs 6. Conversation begins ``` Skills and CLAUDE.md both load at startup. Skills cost ~100 tokens each for metadata. The full body only loads when invoked. ### Can I have private skills? Yes. All skills in `skill.cc/` are discoverable by Claude Code. Whether you publish them to `https://skill.cc/` is a separate deploy step. Skills like `wallet` or `gatekeep` stay local — they never hit the web. ### How many skills can I have? As many as fit in the 15k character budget. At ~200-500 chars per description, that's roughly 30-75 skills before you need to raise the budget. Monitor with `/context` — the Skills line shows total tokens. --- *This namespace is the product. The product is this namespace.* *Domain: skill.cc — owned and operated.*