AutoGineer
Generated banner for Agent Skill Stack
Generated logo for Agent Skill Stack

Agent Skill Stack

GitHubOfficialFirst committed by neilchen2000-pixelDistributed by GitHub

  • Skill
  • Meta (authoring, orchestration, planning, memory)
  • Agent tooling
  • MIT
  • Low risk
  • Has scripts
Download ZIP

From the author

Find, evaluate, and assemble the smallest compatible set of AI Agent Skills for an end-to-end natural-language goal. Use when a user wants Skills for a multi-step workflow, asks which Skills fit a project, needs an installed-Skill audit or conflict check, has low Skill recall, wants indirect helpers such as humanizers or compliance checks, or wants a project-specific Skill Stack with controlled installation. Search local Skills, registries, GitHub, and OpenCLI; compare adoption, verified fit, safety, and overlap. Do not use for locating one known or common Skill; use the generic find-skills workflow.
— the description by neilchen2000-pixel

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The agent-skill-stack skill provides a structured methodology for identifying and organizing the optimal set of AI agent skills required to complete a multi-step project. It emphasizes a user-centric approach, translating complex technical requirements into plain-language recommendations while ensuring safety, compatibility, and minimal redundancy. By searching local indices, registries, and repositories, it evaluates candidates based on verified capabilities, community adoption, and security, ultimately helping users build a project-specific skill stack with controlled installation.

What it does

  • Decomposes complex user goals into a logical, multi-step workflow.
  • Searches local indices, registries, and GitHub for relevant agent skills.
  • Evaluates candidate skills based on safety, adoption, and functional fit.
  • Identifies and resolves potential conflicts between overlapping skills.
  • Presents recommendations in clear, non-technical language for user approval.
  • Manages project-specific skill stacks to ensure controlled and secure installations.

When to use it

  • When you need to assemble a set of skills for a complex, multi-step task.
  • When you want to audit your currently installed skills for conflicts or redundancies.
  • When you need to find the best-fit skills for a project while ensuring safety and reliability.
  • When you require indirect helpers, such as compliance or quality-assurance tools, for your workflow.

Advantages

  • Ensures the smallest, most efficient stack is used for any given goal.
  • Prioritizes security and safety through rigorous verification gates.
  • Reduces technical friction by presenting information in plain language.
  • Prevents skill bloat by managing project-specific profiles.
  • Provides a clear, reproducible process for skill discovery and installation.

Usage examples

“I need to build a research report on renewable energy. Which skills should I use?”
The agent will decompose the research process, search for relevant data-gathering and writing skills, and recommend a stack that includes the necessary research and content-generation tools.
“Check my current skill stack for conflicts and suggest improvements.”
The agent will audit your installed skills, identify any overlapping or redundant capabilities, and propose a refined stack that optimizes performance and reduces potential conflicts.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/github/agent-skill-stack/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip agent-skill-stack.zip -d .agents/skills

Documentation by neilchen2000-pixel

Build an Agent Skill Stack

Build the smallest useful stack for the user's actual outcome. Never force a domain example or a fixed lifecycle onto a different request.

1. Choose the user-facing depth

Default to plain-language mode. Assume the user does not need to understand paths, revisions, hashes, manifests, static analysis, or runtime details.

In plain-language mode, show:

  • what the user is trying to accomplish;

  • the steps in everyday language;

  • which capabilities are already available;

  • which Skills are recommended, optional, overlapping, or unsuitable;

  • how widely each candidate is used;

  • whether it passed an installation safety check and a safe trial;

  • what account access or external actions it may require.

Keep source paths, revisions, file fingerprints, raw scores, audit evidence, and dependency details in the internal record. Show them only when the user asks for technical details or when a specific technical fact is necessary for informed consent.

2. Derive the workflow dynamically

Read references/workflow-model.md. Begin with the final result the user wants, not the domain words in the request.

Ask only questions whose answers materially change the result, access boundary, cost, or stack. Derive the workflow backward from success, then validate it forward from the available starting point.

Do not reuse a previous numbered flow. Do not assume that every request needs research, content creation, publishing, analytics, storage, or automation. Add a step only when the user's outcome requires it.

Stop decomposing when a step has one understandable action, one main result, one access boundary, and one observable success condition. Keep the technical capability cards internal; show the user a short plain-language flow.

3. Search the local index first

Read references/local-index-and-profiles.md.

If a current local Skill index exists, search it before the filesystem or internet. If it is missing or stale, rebuild it from the relevant Skill roots:

python3 scripts/skill_index.py build \
  --root ~/.codex/skills \
  --root ~/.codex/plugins/cache \
  --root .codex/skills \
  --root ~/.agents/skills \
  --root ~/.hermes/skills \
  --output ~/.codex/skill-index.json

The index stores names, summaries, aliases, scope, capability terms, update time, and internal file fingerprints. It never executes a Skill and stores no usage history.

If the current project has .codex/skill-stack.json, treat its active Skills and routing rules as the first-choice stack. Search outside the profile only for an uncovered capability or when the user asks for alternatives. Treat same-name entries from different local roots as a review item; do not silently merge them.

4. Map capabilities, including indirect helpers

For every necessary step, record internally:

  • required input, action, and output;

  • constraints, frequency, and scale;

  • local/read-external/write-external boundary;

  • account, permission, and approval needs;

  • success condition and fallback;

  • predecessor and successor steps.

Then consider cross-cutting needs only where relevant: quality/style, accuracy, compliance, privacy, localization, data quality, orchestration, and observability.

Match Skills by input -> operation -> output, not by title similarity. This allows a Humanizer to match a natural-writing requirement even when the user's domain never appears in its name.

Do not force one Skill per step. A Skill may cover several steps; a step may need a tool, MCP, connector, or general agent capability rather than another Skill.

5. Search with four lenses

Read references/discovery-ranking.md. Search each uncovered capability through:

  1. Direct need: the user's domain and action.

  2. Underlying operation: the actual transformation or data task.

  3. Supporting outcome: quality, safety, style, compliance, evaluation, and monitoring.

  4. Connection method: CLI, MCP, API, connector, browser automation, storage, and handoff.

Expand Chinese/English aliases, verbs, nouns, outputs, and adjacent terminology. Search titles, descriptions, headings, and full SKILL.md content when possible.

Use multiple sources because no registry is complete:

  • the local Skill index and installed inventory;

  • GitHub connector or GitHub file/repository search;

  • npx skills find <query> and skills.sh;

  • agentskill.sh or another registry when available;

  • OpenCLI for broad web discovery and platform-specific research.

Run browser-backed OpenCLI searches sequentially. Do not log in, add credentials, or enable a connector without user approval.

6. Verify and rank candidates

Treat every search hit as a candidate, not a recommendation. Identify the canonical repository and exact Skill path. Read the full Skill and every executable file that installation would make reachable.

Reject or quarantine a candidate when:

  • its source or claimed capability cannot be verified;

  • its structure cannot be installed;

  • mandatory dependencies are incompatible or unavailable;

  • critical credential access, data upload, prompt injection, destructive action, or obfuscation remains unexplained;

  • its only possible test would publish, send, purchase, delete, or change a real account;

  • license or platform terms make the intended use materially uncertain.

Rank candidates that pass these gates with the rubric in references/discovery-ranking.md. Real-world adoption and community evidence account for 25% of the score. Preserve unknown values as unknown.

Prefer the smallest stack that meets all required success conditions. Classify candidates as:

  • Required: needed to complete the outcome.

  • Helpful: improves quality, safety, or efficiency.

  • Alternative: mutually exclusive substitute.

  • Not recommended: blocked, redundant, incompatible, or too uncertain.

7. Analyze conflicts and scope

Read references/security-installation.md. Check identity, activation, instruction, resource, dependency, data-format, permission, and compliance conflicts.

Resolve overlap by selecting one primary Skill, defining a narrow handoff to helpers, keeping alternatives mutually exclusive, or not installing the redundant candidate.

Prefer project-local Skills and a project Skill Stack Profile for task-specific capabilities. Use global installation only for capabilities that should be available broadly.

8. Present recommendations in plain language

Default output:

  1. What you want to achieve: one short restatement.

  2. How the work breaks down: a short numbered flow derived for this request.

  3. What you already have: existing useful Skills and uncovered gaps.

  4. Recommended combination: Required, Helpful, Alternative, and Not recommended.

  5. Why these were chosen: fit, adoption, safety check, safe trial, and conflicts in everyday language.

  6. What needs your decision: account access, paid services, external publishing, or installation selection.

Use labels such as 已具备, 推荐, 可选, 不建议, 安全检查通过, 安全试跑通过, and 最近确认可用. Do not show a hash or local path in the default response.

Offer 查看技术详情 when useful. The technical view may include canonical source, revision, file fingerprint, exact destination, raw evidence, dependencies, permissions, and rollback details.

When the user wants a reusable artifact, create a shareable recommendation card from structured JSON:

python3 scripts/render_stack_card.py \
  --input /path/to/stack-card.json \
  --output /path/to/stack-card.svg

Keep the card understandable without technical paths or raw hashes. Include the goal, selected Skills, each role and status, safety boundary, and verification date.

9. Install only after consent

Recommendation does not authorize installation. Follow references/security-installation.md after the user chooses.

Default to staged installation. Allow a one-click batch only when every selected Skill passed the hard gates, has an exact pinned identity, has no unresolved conflict, will not overwrite an existing destination, and the user explicitly approves the batch.

For already downloaded and checked Skill directories, preview first:

python3 scripts/stage_install.py \
  --source /path/to/skill-a \
  --dest ~/.codex/skills \
  --manifest ./skill-stack-lock.json

Repeat with --apply only after approval. Never silently add credentials, accept new permissions, overwrite an installed Skill, or publish/send/delete external data.

After the user selects the stack, offer to create a project profile in dry-run mode:

python3 scripts/project_profile.py \
  --project /path/to/project \
  --name project-stack \
  --skill skill-a \
  --skill skill-b

Use --apply only after the user confirms the profile.

10. Run a recall check

After installation or profile changes, run a recall check, not a performance benchmark:

  1. a direct request that names the task;

  2. a natural paraphrase that uses different words;

  3. a supporting request that should bring in a helper such as writing quality, fact checking, or compliance.

Confirm that the correct primary and supporting Skills are selected and unrelated Skills stay out. Report a simple result such as 3/3 种说法都能正确识别; keep raw prompts and routing details in the technical view.

Do not collect or store user prompt history, hit/miss logs, or routing feedback.

Files

scripts/stage_install.py

#!/usr/bin/env python3
"""Preview or install already downloaded and audited skill directories without overwrite."""

from __future__ import annotations

import argparse
import hashlib
import json
import os
import re
import shutil
import tempfile
from datetime import datetime, timezone
from pathlib import Path


NAME_RE = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")


def parse_name(skill_file: Path) -> str:
    lines = skill_file.read_text(encoding="utf-8", errors="strict").splitlines()
    if not lines or lines[0].strip() != "---":
        raise ValueError(f"{skill_file}: missing opening frontmatter delimiter")
    end = next((i for i in range(1, len(lines)) if lines[i].strip() == "---"), None)
    if end is None:
        raise ValueError(f"{skill_file}: missing closing frontmatter delimiter")
    for line in lines[1:end]:
        match = re.match(r"^name:\s*([^#]+?)\s*$", line)
        if match:
            name = match.group(1).strip().strip('"\'')
            if len(name) > 63 or not NAME_RE.fullmatch(name):
                raise ValueError(f"{skill_file}: invalid skill name {name!r}")
            return name
    raise ValueError(f"{skill_file}: missing name")


def collect_files(source: Path) -> list[Path]:
    files: list[Path] = []
    for current, dirs, filenames in os.walk(source, followlinks=False):
        current_path = Path(current)
        for dirname in dirs:
            path = current_path / dirname
            if path.is_symlink():
                raise ValueError(f"symlinked directories are not allowed: {path}")
        for filename in filenames:
            path = current_path / filename
            if path.is_symlink():
                raise ValueError(f"symlinked files are not allowed: {path}")
            if not path.is_file():
                raise ValueError(f"unsupported filesystem entry: {path}")
            files.append(path)
    return sorted(files, key=lambda path: str(path.relative_to(source)))


def sha256_file(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def source_record(source: Path, dest: Path) -> dict[str, object]:
    if source.is_symlink() or not source.is_dir():
        raise ValueError(f"source is not a regular directory: {source}")
    skill_file = source / "SKILL.md"
    if not skill_file.is_file():
        raise ValueError(f"source has no SKILL.md: {source}")
    name = parse_name(skill_file)
    files = collect_files(source)
    file_records = [
        {
            "path": str(path.relative_to(source)),
            "sha256": sha256_file(path),
            "bytes": path.stat().st_size,
        }
        for path in files
    ]
    aggregate = hashlib.sha256()
    for item in file_records:
        aggregate.update(str(item["path"]).encode("utf-8"))
        aggregate.update(str(item["sha256"]).encode("ascii"))
    return {
        "name": name,
        "source": str(source),
        "target": str(dest / name),
        "content_sha256": aggregate.hexdigest(),
        "file_count": len(file_records),
        "files": file_records,
    }


def atomic_write_json(path: Path, payload: dict[str, object]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with tempfile.NamedTemporaryFile("w", encoding="utf-8", dir=path.parent, delete=False) as handle:
        json.dump(payload, handle, ensure_ascii=False, indent=2)
        handle.write("\n")
        temp_name = handle.name
    os.replace(temp_name, path)


def apply_install(records: list[dict[str, object]], dest: Path) -> list[str]:
    dest.mkdir(parents=True, exist_ok=True)
    staging = Path(tempfile.mkdtemp(prefix=".agent-skill-stack-", dir=dest))
    created: list[str] = []
    try:
        for record in records:
            source = Path(str(record["source"]))
            staged = staging / str(record["name"])
            shutil.copytree(source, staged, symlinks=False)
            if parse_name(staged / "SKILL.md") != record["name"]:
                raise RuntimeError(f"staged validation failed for {record['name']}")
        for record in records:
            staged = staging / str(record["name"])
            target = Path(str(record["target"]))
            os.replace(staged, target)
            created.append(str(target))
        return created
    finally:
        shutil.rmtree(staging, ignore_errors=True)


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--source", action="append", required=True, help="Audited local skill directory; repeatable")
    parser.add_argument("--dest", required=True, help="Destination skill root")
    parser.add_argument("--manifest", required=True, help="Path for the lock/preview manifest")
    parser.add_argument("--apply", action="store_true", help="Copy after validation; default is dry-run")
    parser.add_argument(
        "--record-existing",
        action="store_true",
        help="Record a lock manifest when each source is already its exact destination",
    )
    args = parser.parse_args()

    if args.apply and args.record_existing:
        raise SystemExit("--apply and --record-existing are mutually exclusive")

    dest = Path(os.path.expandvars(os.path.expanduser(args.dest))).resolve()
    manifest = Path(os.path.expandvars(os.path.expanduser(args.manifest))).resolve()
    sources = [Path(os.path.expandvars(os.path.expanduser(raw))).resolve() for raw in args.source]

    records = [source_record(source, dest) for source in sources]
    names = [str(record["name"]) for record in records]
    if len(names) != len(set(names)):
        raise SystemExit("duplicate skill names in selected sources")

    existing = [str(record["target"]) for record in records if Path(str(record["target"])).exists()]
    if args.record_existing:
        mismatched = [
            str(record["name"])
            for record in records
            if Path(str(record["source"])).resolve() != Path(str(record["target"])).resolve()
        ]
        if mismatched:
            raise SystemExit("--record-existing requires source to equal target for: " + ", ".join(mismatched))
    elif existing:
        raise SystemExit("refusing to overwrite existing destinations: " + ", ".join(existing))

    payload: dict[str, object] = {
        "schema": 1,
        "generated_at": datetime.now(timezone.utc).isoformat(),
        "mode": "record-existing" if args.record_existing else ("apply" if args.apply else "dry-run"),
        "destination": str(dest),
        "skills": records,
        "created": [],
        "notice": "Sources must be downloaded and audited before using this installer. Existing targets are never overwritten.",
    }

    if args.record_existing:
        payload["status"] = "recorded"
    elif args.apply:
        payload["created"] = apply_install(records, dest)
        payload["status"] = "installed"
    else:
        payload["status"] = "planned"

    atomic_write_json(manifest, payload)
    print(json.dumps(payload, ensure_ascii=False, indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Requirements and compatibility

Written for: GitHub Copilot

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python, Needs Node.js

Security

What our scanner noticed· Low risk

  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by
GitHub avatar of neilchen2000-pixelneilchen2000-pixel
Publisher
GitHub (Official)
Distributed by
GitHub
Source
github/awesome-copilot · skills/agent-skill-stack · commit 797337f
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
neilchen2000-pixel

AutoGineer is not affiliated with or endorsed by neilchen2000-pixel or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download agent-skill-stack.zip