CommunityResearch & Data Analysisgithub.com

skills-summarize-audit

Skills Audit & Project Profile — Multi-dimensional profiling, scoring, capacity analysis, and optimization for your skill library and projects.

What is skills-summarize-audit?

This skill, skills-summarize-audit, is a universal agent tool auditor that generates an actionable audit report for your skill library or current project. It performs multi-dimensional profiling (skill library health, project tech stack), 7-dimensional scoring (S/A/B/C/D), capacity analysis, and optimization recommendations. It identifies zombie skills and redundant overlaps, calculates effective capacity with multi-factor warnings, and provides a clear action list for archiving, installing, or updating skills. The skill supports one-click rollback with `--undo`, integrates with CI/CD pipelines (GitHub Actions), and offers both deep and quick audit modes. It is designed for AI agent platforms like Claude, Codex, Cursor, and Codex, and works by scanning skill directories, reading `capability-dimensions.yaml`, and leveraging external signals (GitHub stars, npm downloads) to inform recommendations.

Works with✓Claude Code✓Codex CLI✓Cursor
npx skills add gtbwpkwjnb-alt/skills-summarize-audit-skill

Installed? Explore more Research & Data Analysis skills: affaan-m/uspto-database, affaan-m/scholar-evaluation, affaan-m/literature-review · View all 6 →

Ask in your favorite AI

Open a new chat with this agent skill pre-loaded.

Documentation

Skills-Summarize-Audit — Skill Library & Project Profile-Driven Audit (Linked with summarize)

Perform multi-dimensional profiling, 7-dimensional scoring, capacity analysis, and optimization recommendations for your skill library or current project, ultimately outputting an actionable audit report.

It helps you:

  • Understand the health of your skill library (🟢/🟡/🔴) and trend changes (📈 ↑/↓)
  • Discover zombie skills and redundant overlaps
  • Calculate how many more skills an Agent can install (multi-factor effective capacity warnings)
  • Get an actionable list of archive/install/update operations
  • Roll back after mistakes with a single command (--undo)
  • Integrate into CI/CD pipelines (JSON output + gating logic)

Trigger Words

This skill uses standalone word triggering: trigger words must be sent independently (optionally with subcommands) and will NOT trigger in the middle of a sentence. Designed to work with the summarize skill; 技能总结 can directly trigger an audit.

  • Skill Audit: skills-audit, skill-audit, skill-check, capability-audit, tool-audit, skills-summarize-audit
  • Project Audit: project-audit, project-check, project-diagnosis, project-profile, env-audit
  • Undo Operations: undo-snapshot, rollback, revert
  • Subcommands: deep, recommend, profile, health, quick, ci/--ci, undo/--undo

Trigger Matrix

ModeEnglish TriggerImmediate Action
Skill Auditskills-audit, skill-audit, skill-check, capability-audit, tool-audit, skills-summarize-auditFull audit of skill library
Project Auditproject-audit, project-check, project-diagnosis, project-profile, env-auditAudit of current project environment
Undoundo-snapshot, rollback, revertRoll back the last audit action

Synonyms (audit = check = diagnosis, capability = skill = tool, environment = project) are automatically normalized into the corresponding mode.

Trigger Behavior

Will Trigger ✅Will NOT Trigger ❌
skills-audit (sent standalone)run skills-audit on this (in sentence)
skill-check (sent standalone)please do a skill-check (in sentence)
project-audit (sent standalone)I need a project-audit (in sentence)
undo-snapshot (sent standalone)undo that snapshot (in sentence)
skills-audit deep (standalone + subcommand)deep audit the skills (in sentence)

Language Adaptation: If the user's primary language is English (>70% English in conversation), English trigger words are matched first, and the report output language switches to en.


When to Use

  • Skill Audit Mode: Periodically maintain skill library health (recommended every 2-4 weeks) or after major changes to the skill library. Can be linked with summarize: run summarize → discover skill accumulation → suggest skills-audit.
  • Project Audit Mode: Quickly understand the tech stack and tool chain when taking over a new project, or assess environment health before refactoring.

Prerequisites

Hard Requirements (auto-detected + install guidance if missing)

  • codegraph — Code structure and symbol query, core skill analysis engine. If missing, attempts automatic installation.
  • git — Version comparison, snapshots, and rollback. If missing, attempts automatic installation.
  • config.yaml — The only configuration source in this skill's directory. If missing, generates from template.

Soft Requirements (automatically created if missing)

  • user-profile.md — User profile. If missing, guides creation through Q&A.

Capabilities

skills-summarize-audit provides the following core capabilities (v6.0.0 adds capability dimension matrix, quality signals, community feed, and ecosystem radar):

  • Project tech stack profiling and project type identification
  • Full skill library scan and incremental inventory
  • Capability dimension matrix construction (~12 dimensions, v6.0.0)
  • Quality signal reading (linked with summarize error ledger, v6.0.0)
  • Multi-factor effective capacity analysis and capacity warnings
  • 6 skill activity checks
  • 7-dimensional S/A/B/C/D scoring with mandatory justification
  • T3 activity verification and false archiving risk control
  • Community feed search (capability gap-driven GitHub search, v6.0.0)
  • Tool recommendations based on capability complementarity (replace/complement/supplement/unrelated, v6.0.0)
  • Ecosystem radar section (conditional output, only shown when issues exist, v6.0.0)
  • Per-skill deep reading and external source verification
  • External signal caching and 3-layer recommendation engine
  • 30-second summary report and trend comparison
  • Snapshot backup and --undo rollback
  • CI/CD non-interactive mode and JSON gating output
  • Trigger word translation and description quality check

Detailed capability table by execution phase:

PhaseCapabilityDescription
⓪ ConfigurationMulti-platform adaptationAutomatic detection of Codex/Claude/Cursor/Coze platform
① ProfilingProject tech stack scanAutomatic identification of 15+ project types (Web/Rust/Python/Go/Java...)
② InventoryFull skill library scan + capability mappingScans 4 paths + capability-dimensions.yaml mapping (v6.0.0)
②-bisCapacity analysisMulti-factor effective capacity calculation (token + conflict + cognitive capacity)
②-terActivity check6 checks to verify skill usability (agent reachability/MCP/command/trigger/data/usage evidence)
④ Scoring7-dimension scoring + quality signals7-dimension scoring + reads summarize error ledger (v6.0.0)
④-aT3 activity verificationVerifies usage evidence/modification time/trigger records before archiving to reduce false archiving rate
④-bisDeep readingS/A full deep read, B (profile-related) full read, B (unrelated) summary
⑤aExternal signalsGitHub⭐/npm📥 cached collection
⑤-aaCommunity feedCapability gap-driven GitHub search (v6.0.0)
⑤bCapability matrix recommendation engineRecommendations based on capability complementarity (replace/complement/supplement/unrelated, v6.0.0)
⑥Report generation + Ecosystem radar30-second summary + capacity block + score table + conditional ecosystem radar section (v6.0.0)
⑦-aSnapshot backupAuto-backup all editable skills before execution
⑦-dOperation rollback--undo to revert any execution, keeps 7-day snapshots
CINon-interactive auditJSON output + health/t3/actions 3 gates, integrates with GitHub Actions

When NOT to Use

  • Single file edits, real-time debugging, minimal projects (no skill dependencies), or when only installing a single skill
  • Low-resource environments (audit consumes ~5K-15K tokens per run)

Execution Flow

After triggering, read references/execution-flow.md for the complete flow, scoring table, capacity calculation, report templates, and CI rules. Main file retains only entry points and key rules.

⓪ Pre-configuration → ① Project profiling → ② Skill inventory + capacity collection → **②-ter Activity check**
→ ③ Load reference data → ④ Layered scoring
→ ④-bis Deep reading → ⑤ External signals + recommendations → ⑥ Generate report → ⑥-bis Audit verification → ⑦ Execution → ⑧ Persistence

Key Rules

  • Profiling: Only scan the current directory. Extract pain points from data sources. Do NOT guess. Write results to {project}/.agents/project-profile.md.
  • Layering: T1 (hits core activities) → keep; T2 (general) → keep; T3 (specialized) → suggest archiving.
  • Scoring: 7 dimensions S/A/B/C/D. Each skill must have 1 justification sentence; no justification = unscored.
  • Capacity: Calculate Agent's maximum capacity. Can install ≤1 → 🔴, 2-4 → 🟡, ≥5 → 🟢.
  • External Signals: GitHub⭐ cached for 7 days, npm📥 cached for 30 days. Skip if network is unavailable and annotate. Do NOT fabricate.
  • Recommendations: Each with confidence score (0-10) + ROI. If <7, explicitly mark as "Evaluating"; if <5, require data support to recommend.
  • Execution: Only modify user-level skills (editable=true). System skills are read-only.
  • Golden Rule: When developing/modifying/recommending skills, search and verify first, citing ≥2 independent sources.
  • Activity Check: First audit performs full check. Subsequent audits only check newly installed skills. deep subcommand forces full check. Trigger single-skill biopsy on anomalies.

Output Example

After triggering skills-audit, the 30-second summary block is output first:

🟢 Skill Library Health: Good
🛠️ Key Actions: Update 1 outdated skill, Archive 2 T3 skills
💰 Estimated Savings: ~3200 tokens/run (reducing low-value skill injection)

Followed by a score table snippet (example):

SkillOverallFitValueFreshCommunityROINoveltyContaminationSuggestion
codegraphS5544555Keep, core tool
old-linterC2223224Suggest archiving

Full report format in references/report-template.md.


Project Type Identification Rules

Core inference rules (full mapping in references/project-types.yaml):

  • package.json → Web/Node/Full Stack
  • Cargo.toml → Rust · pyproject.toml → Python · go.mod → Go
  • pom.xml/build.gradle → Java · .csproj → C# · pubspec.yaml → Flutter
  • CMakeLists.txt → C/C++ · Gemfile → Ruby
  • Multiple SKILL.md + MEMORY.md → AI Agent Skill Development

Boundary Rules (Quick Reference)

  • Trigger: Standalone word trigger, NOT in sentence
  • Layering: T1/T2/T3 based solely on profile "core activities"
  • Scoring: 5 levels S/A/B/C/D. Mandatory justification. No justification = unscored.
  • Deep Analysis: Read full body. Gaps must be verified with tools.
  • Report: Output only if there is content. No fallback for empty sections.
  • Recommendations: Confidence score 0-10 + ROI. Do not recommend if <5; require data support.
  • Confirm Execution: User confirmation required for operations. System skills are read-only.
  • Golden Rule: Search and verify first, ≥2 sources.

Platform Configuration & CI/CD

Supported platforms: platforms/zcode.yaml · platforms/workbuddy.yaml · platforms/claude.yaml · platforms/codex.yaml · platforms/cursor.yaml · platforms/default.yaml.

CI Mode (skills-audit --ci or skills-summarize-audit --ci): Non-interactive, JSON output, skip deep reading, bounded by ci.max_tokens budget in config.yaml. Gating logic: health=🔴 → exit_code=1 · actions_required>5 → exit_code=2 · t3_ratio>0.35 → exit_code=3. GitHub Actions template in references/ci-github-actions.yml.

SkillSpector Security Scan (optional): When enabled via config.yaml → security_scan, results are incorporated into the Value dimension (Critical→D, High→C, Pass→+0.5 grade). SkillSpector is an external process and does not consume Agent Tokens.


File Structure

skills-summarize-audit/
├── SKILL.md                    # Main skill file
├── VERSION                     # Version number
├── LICENSE                     # MIT
├── README.md                   # Overview and installation
├── config.yaml                 # Audit configuration
├── platforms/                  # Platform adaptation configurations
├── references/                 # Reference documents
│   ├── execution-flow.md       # Execution flow index
│   ├── flow/                   # Detailed steps per phase (19 sub-files)
│   ├── project-types.yaml      # Project type mapping
│   ├── skill-registry.yaml     # Skill registry
│   ├── deep-analysis-template.md
│   ├── description-quality.md
│   ├── report-template.md
│   ├── ci-output-schema.md
│   ├── ci-github-actions.yml
│   └── recommendation-examples.md
├── tests/                      # Test suite and verification scripts
├── .data/                      # Runtime data (logs/cache/statistics/profiles/external signals)
├── install.ps1 / install.sh    # Installation scripts
└── CHANGELOG.md                # Changelog

Installation

One-click installation and manual installation details in references/installation.md (if missing, refer to README.md).

After installation, enter skills-audit, skill-check, or skills-summarize-audit to trigger.


Feedback

🐛 GitHub Issues


License

MIT — see LICENSE file.

Related Skills