interface:
  display_name: "Daniel's High-Star GitHub Skills"
  short_description: "Discover and safely install Daniel's GitHub skill picks"
  default_prompt: "Use $agent-skill-repository-index to choose, verify, and safely install the best-fit skill from Daniel’s recommended GitHub repositories."

# Safe Skill Installation and Lifecycle

## Table of Contents

- [Choose the installation mode](#choose-the-installation-mode)
- [Preflight](#preflight)
- [Codex](#codex)
- [Claude Code and OpenClaw](#claude-code-and-openclaw)
- [Validate](#validate)
- [Update](#update)
- [Rollback or remove](#rollback-or-remove)
- [Installation receipt](#installation-receipt)

## Choose the Installation Mode

| Candidate | Action |
|---|---|
| Catalog with no runnable root skill | Do not install; search it and follow the chosen item to upstream. |
| Repository containing many skills | Select and review one subdirectory. Never expose the repository root globally. |
| Passive single skill with compatible metadata | Link the reviewed directory or use the client's native installer. |
| Skill requiring Codex-specific wording or tools | Copy to a personal Codex skill root, normalize, and record provenance. |
| Plugin, hook suite, MCP server, daemon, memory system, browser profile, deployer, or connector | Keep quarantined until the user explicitly authorizes those runtime effects. |

## Preflight

1. Resolve the exact upstream URL and local source directory.
2. Confirm `git remote get-url origin`, commit, license, and worktree status.
3. Read the complete candidate directory and identify every executable or external action.
4. Compare its name and trigger semantics with installed skills.
5. Select an explicit destination and verify it is absent. Never overwrite an existing file, directory, or symlink.
6. Obtain explicit approval for any quarantined behavior; ordinary passive local skill installation needs no extra approval when the user already requested it.

## Codex

Prefer these methods in order:

1. Use the built-in `$skill-installer` for a supported GitHub repository or subpath.
2. For a clean reviewed local source, create one symlink in the documented shared personal skill root, represented here as `<agent-skills-dir>/<skill-name>`.
3. When adaptation is required, copy the complete skill into `<codex-home>/skills/<skill-name>`, normalize frontmatter to only `name` and `description`, and generate `agents/openai.yaml`.
4. For project-only behavior, use the project's documented `.agents/skills/<skill-name>` location instead of a personal-global target.

Before linking, resolve both source and target to explicit absolute paths. Refuse if the target already exists. Link only the directory containing the reviewed `SKILL.md`.

## Claude Code and OpenClaw

- Prefer the upstream repository's documented marketplace or plugin installation when the candidate is a plugin rather than a plain skill.
- For a plain Claude Code skill, use the client-documented `<claude-config>/skills/<skill-name>` location only after adapting unsupported tool names when necessary.
- For a plain OpenClaw skill, use the documented `<openclaw-config>/skills/<skill-name>` location and review OpenClaw-specific hooks, services, and credentials separately.
- Do not copy one client's hooks, permissions, slash commands, or tool metadata literally into another client.

## Validate

For Codex-compatible skills, run:

```bash
python3 <codex-home>/skills/.system/skill-creator/scripts/quick_validate.py <installed-skill-dir>
```

Also verify:

- every referenced relative resource resolves;
- folder name equals frontmatter `name`;
- the global or project link resolves to the intended source;
- one representative request triggers the skill;
- one nearby but out-of-scope request does not trigger it;
- no duplicate name or substantially overlapping description was introduced.

## Update

1. Inspect local changes before fetching. Preserve dirty clones.
2. Fetch the upstream and compare commits.
3. Fast-forward only a clean, non-diverged clone.
4. Re-run the candidate audit, risk scan, validator, and trigger tests before accepting the update.
5. For normalized copies, review and port upstream changes deliberately; do not overwrite the adaptation wholesale.

## Rollback or Remove

- For a symlink, verify `readlink` points to the expected source, then unlink only that exact link.
- For a copied skill, move the exact directory to a dated quarantine or Trash location rather than deleting it immediately.
- For a plugin or runtime, use its native disable/uninstall flow and confirm hooks, services, MCP entries, credentials, and background processes are removed or intentionally retained.
- Restore the recorded previous commit or prior normalized copy, then rerun validation.

## Installation Receipt

Return and record:

```text
upstream_url:
source_subpath:
source_commit:
license:
classification:
destination:
install_method: native | symlink | normalized-copy | project-local
adaptations:
validation:
positive_trigger:
negative_trigger:
update_method:
rollback_method:
```

# Daniel's Recommended GitHub Skill Sources

This portable source index is used by AGI Super Team. A maintainer may keep reviewed mirrors under a private `<repository-mirror-root>/<local>` directory; verify each remote and commit before migration. See [star-snapshot.md](star-snapshot.md) for Daniel's supplied July 2026 popularity snapshot and [installing.md](installing.md) for the safe lifecycle workflow. Stars do not determine safety.

## Tier S

| Repository | Local | Class | Best use |
|---|---|---|---|
| [anthropics/skills](https://github.com/anthropics/skills) | `skills` | LIBRARY | Official reference implementations and format conventions. |
| [obra/superpowers](https://github.com/obra/superpowers) | `superpowers` | LIBRARY | Engineering methodology; use its Codex plugin only when explicitly wanted. |
| [affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code) | `everything-claude-code` | LIBRARY; runtime QUARANTINE | Broad operator patterns; select passive skills only. |
| [forrestchang/andrej-karpathy-skills](https://github.com/forrestchang/andrej-karpathy-skills) | `andrej-karpathy-skills` | DAILY | Compact coding-behavior guardrails. |
| [mattpocock/skills](https://github.com/mattpocock/skills) | `mattpocock-skills` | LIBRARY with selected DAILY | TypeScript, teaching, writing, QA, planning, and issue workflows. |
| [leonxlnx/taste-skill](https://github.com/leonxlnx/taste-skill) | `taste-skill` | LIBRARY with selected DAILY | Anti-slop interface design; `design-taste-frontend` is the reviewed global candidate. |
| [shanraisshan/claude-code-best-practice](https://github.com/shanraisshan/claude-code-best-practice) | `claude-code-best-practice` | LIBRARY; examples QUARANTINE | Claude Code concepts, settings, hooks, and MCP examples. |

## Tier A

| Repository | Local | Class | Best use |
|---|---|---|---|
| [hesreallyhim/awesome-claude-code](https://github.com/hesreallyhim/awesome-claude-code) | `awesome-claude-code` | LIBRARY | Claude Code resource discovery. |
| [addyosmani/agent-skills](https://github.com/addyosmani/agent-skills) | `agent-skills` | LIBRARY with selected DAILY | Production SDLC workflows. |
| [alchaincyf/nuwa-skill](https://github.com/alchaincyf/nuwa-skill) | `nuwa-skill` | LIBRARY | Researching and distilling people’s mental models. |
| [ComposioHQ/awesome-claude-skills](https://github.com/ComposioHQ/awesome-claude-skills) | `awesome-claude-skills` | LIBRARY; connectors QUARANTINE | Large discovery catalog; review auth actions separately. |
| [pbakaus/impeccable](https://github.com/pbakaus/impeccable) | `impeccable` | DAILY candidate | UI anti-pattern audit and design quality. |
| [OthmanAdi/planning-with-files](https://github.com/OthmanAdi/planning-with-files) | `planning-with-files` | DAILY | Persistent file-backed planning; keep one canonical installation. |
| [Lum1104/Understand-Anything](https://github.com/Lum1104/Understand-Anything) | `Understand-Anything` | LIBRARY; automation QUARANTINE | Knowledge graphs; services and hooks remain opt-in. |
| [VoltAgent/awesome-openclaw-skills](https://github.com/VoltAgent/awesome-openclaw-skills) | `awesome-openclaw-skills` | LIBRARY | OpenClaw/ClawHub discovery. |
| [LearnPrompt/ai-news-radar](https://github.com/LearnPrompt/ai-news-radar) | `ai-news-radar` | DAILY reader; pipeline LIBRARY | Zero-key AI news reader; publishing pipeline is separate. |
| [composio-community/awesome-codex-skills](https://github.com/composio-community/awesome-codex-skills) | `awesome-codex-skills` | LIBRARY; connectors QUARANTINE | Codex-oriented skill discovery. |
| [alirezarezvani/claude-skills](https://github.com/alirezarezvani/claude-skills) | `claude-skills` | LIBRARY | Broad production catalog; select one domain skill at a time. |
| [wshobson/agents](https://github.com/wshobson/agents) | `agents` | LIBRARY with plugin candidates | Specialist agents and single-purpose plugins. |
| [ruvnet/claude-flow](https://github.com/ruvnet/claude-flow) | `claude-flow` | QUARANTINE runtime; docs LIBRARY | Orchestration, hooks, daemon, federation, and persistent memory. |

## Tier B

| Repository | Local | Class | Best use |
|---|---|---|---|
| [VoltAgent/awesome-agent-skills](https://github.com/VoltAgent/awesome-agent-skills) | `awesome-agent-skills` | LIBRARY | Cross-agent discovery; trace every item to upstream. |
| [thedotmack/claude-mem](https://github.com/thedotmack/claude-mem) | `claude-mem` | QUARANTINE | Persistent memory, hooks, worker, database, and MCP. |
| [supermemoryai/supermemory](https://github.com/supermemoryai/supermemory) | `supermemory` | QUARANTINE | Memory/RAG platform with external data and profiles. |
| [garrytan/gstack](https://github.com/garrytan/gstack) | `gstack` | LIBRARY methods; runtime QUARANTINE | Founder workflows; full setup adds browser, daemon, deploy, and updater behavior. |
| [ruvnet/ruflo](https://github.com/ruvnet/ruflo) | `ruflo` | DUPLICATE / QUARANTINE | Same current code lineage as `claude-flow`; choose one canonical source. |
| [0xfurai/claude-code-subagents](https://github.com/0xfurai/claude-code-subagents) | `claude-code-subagents` | LIBRARY | Claude-specific specialist prompt library. |
| [robwhite4/claude-memory](https://github.com/robwhite4/claude-memory) | `claude-memory` | QUARANTINE | Background session rotation, backups, and persistent memory. |

## Specialty

| Repository | Local | Class | Best use |
|---|---|---|---|
| [zarazhangrui/frontend-slides](https://github.com/zarazhangrui/frontend-slides) | `frontend-slides` | LIBRARY / design candidate | HTML presentations; deployment and runtime downloads remain explicit. |
| [nashsu/AutoCLI](https://github.com/nashsu/AutoCLI) | `AutoCLI` | QUARANTINE | Authenticated browser state, extension, adapters, and optional cloud sync. |
| [ZhuLinsen/daily_stock_analysis](https://github.com/ZhuLinsen/daily_stock_analysis) | `daily_stock_analysis` | QUARANTINE application | Financial-analysis application, scheduled automation, and push channels. |

## General Discovery

| Repository | Local | Class | Best use |
|---|---|---|---|
| [sindresorhus/awesome](https://github.com/sindresorhus/awesome) | `awesome` | LIBRARY | General curated-list index. It has no `SKILL.md` and does not overlap functionally with `taste-skill`. |

## Selection Rules

1. Search installed Codex-native skills before migrating anything.
2. Prefer a narrow upstream skill over an aggregator copy.
3. Read the candidate `SKILL.md` completely and inspect its adjacent resources.
4. Scan for secrets, hooks, persistence, external writes, deployment, tunnels, and auto-update behavior.
5. Record provenance, pinned commit, license, adaptations, trigger examples, and non-trigger examples.
6. Link or copy only the reviewed skill directory; never expose the entire repository by default.

# Daniel's Star Snapshot

Approximate GitHub stars supplied in Daniel's July 2026 source list. Values change continuously; fetch live counts before making a current ranking. A high count does not override license, compatibility, provenance, or safety review.

| Repository | Approximate stars in supplied list |
|---|---:|
| `sindresorhus/awesome` | 487K |
| `obra/superpowers` | 192K |
| `affaan-m/everything-claude-code` | 182K |
| `anthropics/skills` | 135K |
| `forrestchang/andrej-karpathy-skills` | 131K |
| `garrytan/gstack` | 97.4K |
| `mattpocock/skills` | 84K |
| `leonxlnx/taste-skill` | 61K |
| `shanraisshan/claude-code-best-practice` | 53.6K |
| `ruvnet/ruflo` | 51.4K |
| `hesreallyhim/awesome-claude-code` | 43.4K |
| `addyosmani/agent-skills` | 42K |
| `ComposioHQ/awesome-claude-skills` | 34.5K |
| `pbakaus/impeccable` | 27.6K |
| `alchaincyf/nuwa-skill` | 21K |
| `OthmanAdi/planning-with-files` | 20K |
| `wshobson/agents` | 18.7K |
| `zarazhangrui/frontend-slides` | 18K |
| `supermemoryai/supermemory` | 16.7K |
| `alirezarezvani/claude-skills` | 15.4K |
| `composio-community/awesome-codex-skills` | 15.2K |
| `thedotmack/claude-mem` | 12.8K |
| `Lum1104/Understand-Anything` | 12K |
| `ruvnet/claude-flow` | 11K |
| `VoltAgent/awesome-openclaw-skills` | 8K |
| `VoltAgent/awesome-agent-skills` | 5K |
| `0xfurai/claude-code-subagents` | 2K |
| `LearnPrompt/ai-news-radar` | Not supplied |
| `robwhite4/claude-memory` | Not supplied |
| `nashsu/AutoCLI` | Not supplied |
| `ZhuLinsen/daily_stock_analysis` | Not supplied |

When live ranking is required, prefer the GitHub API or GitHub CLI and cite the observation date. Do not rewrite this snapshot automatically.

#!/usr/bin/env python3
"""Verify repository-index links, local clone identities, and optional remotes."""

from __future__ import annotations

import argparse
import re
import subprocess
import sys
from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
from pathlib import Path


ROW_PATTERN = re.compile(
    r"^\| \[([^]]+)\]\((https://github\.com/[^)]+)\) \| `([^`]+)` \|"
)


@dataclass(frozen=True)
class Repository:
    slug: str
    url: str
    local: str


def parse_index(reference: Path) -> list[Repository]:
    repositories: list[Repository] = []
    for line in reference.read_text(encoding="utf-8").splitlines():
        match = ROW_PATTERN.match(line)
        if match:
            repositories.append(Repository(*match.groups()))
    return repositories


def github_slug(value: str) -> str | None:
    match = re.search(r"github\.com[/:]([^/]+/[^/]+?)(?:\.git)?$", value)
    return match.group(1).lower() if match else None


def git_output(*args: str) -> str:
    return subprocess.run(
        ["git", *args],
        check=True,
        capture_output=True,
        text=True,
        timeout=30,
    ).stdout.strip()


def check_local(repository: Repository, root: Path) -> str | None:
    clone = root / repository.local
    if not (clone / ".git").exists():
        return f"missing clone: {clone}"
    try:
        remote = git_output("-C", str(clone), "remote", "get-url", "origin")
    except (subprocess.SubprocessError, OSError) as error:
        return f"cannot read origin: {error}"
    expected = repository.slug.lower()
    actual = github_slug(remote)
    if actual != expected:
        return f"origin mismatch: expected {expected}, got {remote}"
    return None


def check_remote(repository: Repository) -> str | None:
    try:
        subprocess.run(
            ["git", "ls-remote", "--exit-code", repository.url, "HEAD"],
            check=True,
            capture_output=True,
            text=True,
            timeout=45,
        )
    except (subprocess.SubprocessError, OSError) as error:
        return f"remote unreachable: {error}"
    return None


def main() -> int:
    skill_root = Path(__file__).resolve().parent.parent
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--reference",
        type=Path,
        default=skill_root / "references" / "repositories.md",
    )
    parser.add_argument("--repo-root", type=Path)
    parser.add_argument("--remote", action="store_true")
    parser.add_argument("--expected-count", type=int)
    args = parser.parse_args()

    repositories = parse_index(args.reference)
    errors: list[str] = []
    if args.expected_count is not None and len(repositories) != args.expected_count:
        errors.append(
            f"entry count mismatch: expected {args.expected_count}, got {len(repositories)}"
        )
    if len({item.slug.lower() for item in repositories}) != len(repositories):
        errors.append("duplicate repository slug")
    if len({item.local for item in repositories}) != len(repositories):
        errors.append("duplicate local directory")
    for repository in repositories:
        if github_slug(repository.url) != repository.slug.lower():
            errors.append(
                f"label/url mismatch: {repository.slug} points to {repository.url}"
            )

    if args.repo_root:
        for repository in repositories:
            if error := check_local(repository, args.repo_root):
                errors.append(f"{repository.slug}: {error}")

    if args.remote:
        with ThreadPoolExecutor(max_workers=6) as executor:
            results = executor.map(check_remote, repositories)
        for repository, error in zip(repositories, results, strict=True):
            if error:
                errors.append(f"{repository.slug}: {error}")

    for error in errors:
        print(f"FAIL {error}")
    if errors:
        return 1
    checks = [f"{len(repositories)} entries"]
    if args.repo_root:
        checks.append("local identities")
    if args.remote:
        checks.append("GitHub remotes")
    print("PASS " + ", ".join(checks))
    return 0


if __name__ == "__main__":
    sys.exit(main())