npm - opencode-skills-collection - Versions diffs - 4.0.53 → 4.0.55 - Mend

opencode-skills-collection 4.0.53 → 4.0.55

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1230) hide show

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

@@ -1,233 +0,0 @@
-# Getting Started with AAS Core
-**New here? Start with AAS Core and let your agent choose a reviewable skill stack from the complete catalog.**
-> **Product boundary:** Codex or Claude owns skill selection. AAS Core provides complete local catalog access, reproducible composition, validation, and plan preview; apply and recovery remain experimental.
-## Start with AAS Core
-AAS Core is the primary product path. Codex or Claude inspects your project, searches and reads the complete catalog through the local read-only AAS MCP, chooses the exact skill IDs, and uses `compose_stack` to propose an `aas-stack.json`. You review those IDs before using the `aas` CLI to validate the manifest and preview a plan.
-```text
-project -> agent -> full local catalog -> agent selection -> compose_stack -> aas-stack.json
-        -> human review -> validate -> plan preview
-```
-Start with the canonical [AAS Core guide](aas-core.md) to configure the MCP and run that flow. The direct installer, plugins, bundles, and manual skill invocation described below remain useful alternatives, especially for hosts without a native AAS MCP adapter.
-> **Need more examples after setup?** Continue with the [Complete Usage Guide](usage.md).
----
-## What Are "Skills"?
-AI Agents (like **Claude Code**, **Gemini**, **Cursor**) are smart, but they lack specific knowledge about your tools.
-**Skills** are specialized instruction manuals (markdown files) that teach your AI how to perform specific tasks perfectly, every time.
-**Analogy:** Your AI is a brilliant intern. **Skills** are the SOPs (Standard Operating Procedures) that make them a Senior Engineer.
----
-## Alternative Path: Direct Skill Distribution and Starter Packs
-Don't panic about the size of the repository. You don't need everything at once.
-We have curated **Starter Packs** to get you running immediately.
-On the direct-install path, you install the library once (npx or clone); Starter Packs are curated lists to help you **pick which skills to use** by role (e.g. Web Wizard, Hacker Pack)—they are not a different way to install.
-If you prefer a packaged install for **Claude Code**, **Codex**, or another Agent Plugins-compatible client, use the plugin distributions described in [plugins.md](plugins.md).
-### 1. Install Skills Directly
-**Option A — npx (easiest):**
-```bash
-npx agentic-awesome-skills --antigravity --skills brainstorming,systematic-debugging --dry-run
-```
-Antigravity installs to `~/.agents/skills`. Because that host may load enough
-installed instructions to exhaust its context or enter a truncation crash loop,
-the bare command and `--antigravity` now require `--skills`, a metadata filter,
-or the explicit `--all` override. Use `--cursor`, `--claude`, `--gemini`,
-`--codex`, `--kiro`, or `--agy` for other tool paths, or `--path <dir>` for a
-custom location. Run `npx agentic-awesome-skills --help` for details.
-The installer uses a shallow clone by default so you get the current library without paying for the full git history on first install.
-For Antigravity, ask a Codex or Claude agent with the read-only AAS Core MCP
-configured to inspect the project, search the complete catalog, and choose exact
-skill IDs. AAS MCP does not install them; after selection, have the agent run the
-preview command above, show you the plan, and repeat it without `--dry-run` only
-after review. Other direct-install targets keep the legacy-compatible complete
-catalog behavior when no selector is supplied and print a risk summary before
-writing. Installed text is not automatically executed, but it can influence an
-agent when loaded, so review an exact set first:
-```bash
-npx agentic-awesome-skills audit --skills brainstorming,backend-dev-guidelines
-npx agentic-awesome-skills --skills brainstorming,backend-dev-guidelines --dry-run
-```
-Use `npx agentic-awesome-skills --antigravity --all` only when you deliberately
-accept the full catalog's context, truncation, and crash-loop risk.
-You can also ask your agent to read the selected `SKILL.md` and every bundled
-file before installation. The static audit reports risky capabilities; it does
-not prove that a skill is safe. See [Security, trust, and antivirus alerts](security-and-antivirus.md).
-If you see a 404 error, use: `npx github:sickn33/agentic-awesome-skills`
-**Option B — git clone:**
-```bash
-# Universal (works for most agents)
-git clone https://github.com/sickn33/agentic-awesome-skills.git .agent/skills
-```
-**Option C — one exact skill with GitHub CLI (preview):**
-```bash
-gh skill preview sickn33/agentic-awesome-skills skills/brainstorming/SKILL.md
-gh skill install sickn33/agentic-awesome-skills skills/brainstorming/SKILL.md \
-  --agent github-copilot --scope user --pin v14.2.0
-```
-GitHub CLI skill support is currently in preview. In this large repository, use an exact `SKILL.md` path to avoid ambiguous canonical/plugin mirrors and unnecessary full-tree discovery. Avoid `--all` unless you intentionally want every discovered skill.
-### 2. Pick Your Persona
-Find the bundle that matches your role (see [bundles.md](bundles.md)):
-| Persona               | Bundle Name    | What's Inside?                                    |
-| :-------------------- | :------------- | :------------------------------------------------ |
-| **Web Developer**     | `Web Wizard`   | React Patterns, Tailwind mastery, Frontend Design |
-| **Security Engineer** | `Hacker Pack`  | OWASP, Metasploit, Pentest Methodology            |
-| **Manager / PM**      | `Product Pack` | Brainstorming, Planning, SEO, Strategy            |
-| **Everything**        | `Essentials`   | Clean Code, Planning, Validation (The Basics)     |
----
-## Bundles vs Workflows
-Bundles and workflows solve different problems:
-- **Bundles** = curated sets by role (what to pick).
-- **Workflows** = step-by-step playbooks (how to execute).
-Start with bundles in [bundles.md](bundles.md), then run a workflow from [workflows.md](workflows.md) when you need guided execution.
-Example:
-> "Use **@antigravity-workflows** and run `ship-saas-mvp` for my project idea."
----
-## How to Use a Skill
-Once installed, just talk to your AI naturally.
-### Example 1: Planning a Feature (**Essentials**)
-> "Use **@brainstorming** to help me design a new login flow."
-**What happens:** The AI loads the brainstorming skill, asks you structured questions, and produces a professional spec.
-### Example 2: Checking Your Code (**Web Wizard**)
-> "Run **@lint-and-validate** on this file and fix errors."
-**What happens:** The AI follows strict linting rules defined in the skill to clean your code.
-### Example 3: Security Audit (**Hacker Pack**)
-> "Use **@api-security-best-practices** to review my API endpoints."
-**What happens:** The AI audits your code against OWASP standards.
----
-## 🔌 Supported Tools
-| Tool            | Status          | Path                                                                  |
-| :-------------- | :-------------- | :-------------------------------------------------------------------- |
-| **Claude Code** | ✅ Full Support | `.claude/skills/` or install via `/plugin marketplace add sickn33/agentic-awesome-skills` |
-| **Gemini CLI**  | ✅ Full Support | `.gemini/skills/`                                                     |
-| **Codex CLI**   | ✅ Full Support | `.codex/skills/` or use the repo-local plugin metadata described in [plugins.md](plugins.md) |
-| **Kiro CLI**    | ✅ Full Support | Global: `~/.kiro/skills/` · Workspace: `.kiro/skills/`                |
-| **Kiro IDE**    | ✅ Full Support | Global: `~/.kiro/skills/` · Workspace: `.kiro/skills/`                |
-| **Antigravity** | ✅ Native       | Global: `~/.agents/skills/` · Workspace: `.agent/skills/` |
-| **Antigravity CLI (`agy`)** | ✅ Full Support | Global slash-command directories: `~/.gemini/antigravity-cli/skills/<skill>/SKILL.md` |
-| **Cursor**      | ✅ Native       | `.cursor/skills/`                                                     |
-| **OpenCode**    | ✅ Full Support | `.agents/skills/` (prefer reduced installs with `--risk`, `--category`, or `--tags`) |
-| **AdaL CLI**    | ✅ Full Support | `.adal/skills/`                                                       |
-| **Copilot**     | ✅ Native (preview) | `gh skill install ... --agent github-copilot` at project or user scope |
----
-## Trust & Safety
-We classify skills so you know what you're running:
-- ⚪ **unknown**: legacy/unclassified content that still needs maintainer triage.
-- 🟢 **none**: pure text/reasoning guidance.
-- 🔵 **safe**: read-only or low-risk operational guidance.
-- 🟠 **critical**: state-changing or deployment-impacting guidance.
-- 🔴 **offensive**: pentest/red-team guidance with an explicit Authorized Use Only warning.
-Community PRs may still submit `risk: unknown`, but maintainers now audit and progressively reconcile those labels using the repo-wide audit/report tooling. High-risk guidance is extra-reviewed with repository-wide `security:docs` scanning before release.
-_Check the [Skill Catalog](../../CATALOG.md) for the full list._
----
-## FAQ
-If you prefer a plugin install instead of copying skills into tool directories, start with [plugins.md](plugins.md).
-For Claude Code, use:
-```text
-/plugin marketplace add sickn33/agentic-awesome-skills
-/plugin install agentic-awesome-skills
-```
-For Codex, this repository also ships a root plugin plus bundle plugins through the repo-local metadata described in [plugins.md](plugins.md).
-For clients implementing Agent Plugins 1.0, use a specialized bundle whose generated status says `Agent Plugins 1.0 portable`. Its directory contains the standard root `plugin.json` and directly discoverable `skills/`; installation itself follows the client's instructions.
-**Q: Do I need to install every skill?**
-A: No. With AAS Core, ask the agent to inspect the project and choose exact IDs from the complete catalog. On the legacy direct-install path, you can install the broad library while the host reads only invoked or relevant skills. **Starter Packs** in [bundles.md](bundles.md) remain human-curated discovery aids.
-**Q: Can I make my own skills?**
-A: Yes! Use the **@skill-creator** skill to build your own.
-**Q: What if Antigravity on Windows gets stuck in a truncation crash loop?**
-A: Follow the recovery steps in [windows-truncation-recovery.md](windows-truncation-recovery.md). It explains which Antigravity storage folders to back up and clear, and includes an optional batch helper adapted from [issue #274](https://github.com/sickn33/agentic-awesome-skills/issues/274).
-**Q: What if Antigravity overloads on Linux or macOS when too many skills are active?**
-A: Use the activation flow in [agent-overload-recovery.md](agent-overload-recovery.md). It shows how to run `scripts/activate-skills.sh` from a cloned repo so you can keep the full library archived and activate only the bundles or skills you need in the live Antigravity directory.
-**Q: What if `agy` does not show installed skills when I type `/`?**
-A: The Antigravity CLI reads skill directories from `~/.gemini/antigravity-cli/skills/<skill>/SKILL.md`. Run `npx agentic-awesome-skills --agy`, restart `agy`, then open `/skills` or type a specific slash command such as `/brainstorming`.
-**Q: What if OpenCode or another `.agents/skills` host becomes unstable with a full install?**
-A: Start with a reduced install instead of copying the whole library. For example: `npx agentic-awesome-skills --path .agents/skills --category development,backend --risk safe,none`. You can narrow further with `--tags` and use a trailing `-` to exclude values such as `typescript-`. To manage a reproducible exact set, first preview it with `npx agentic-awesome-skills@14.3.0 --path .agents/skills --release 14.3.0 --skills frontend-design,backend-dev-guidelines --dry-run`, then remove `--dry-run` only after reviewing the plan. Default and `--release` installs verify the cloned commit against the exact npm release's immutable `gitHead`; `--tag` is an explicit mutable-ref escape hatch and is not release-identity verified.
-**Q: Is this free?**
-A: Yes. Original code and tooling are MIT-licensed, and original documentation/non-code written content is CC BY 4.0. See [../../LICENSE](../../LICENSE) and [../../LICENSE-CONTENT](../../LICENSE-CONTENT).
----
-## Next Steps
-Need a tool-specific starting point first?
-- [Claude Code skills](claude-code-skills.md)
-- [Plugins for compatible agent clients](plugins.md)
-- [Cursor skills](cursor-skills.md)
-- [Codex CLI skills](codex-cli-skills.md)
-- [Gemini CLI skills](gemini-cli-skills.md)
-1. [Configure and use AAS Core](aas-core.md)
-2. [Browse the Bundles](bundles.md)
-3. [See Real-World Examples](../contributors/examples.md)
-4. [Contribute a Skill](../../CONTRIBUTING.md)

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

@@ -1,304 +0,0 @@
-# Kiro CLI Integration Guide
-## Overview
-This guide explains how to use Agentic Awesome Skills with **Kiro CLI**, AWS's agentic AI-powered coding assistant.
-## What is Kiro?
-Kiro is AWS's agentic AI IDE that combines:
-- **Autonomous coding agents** that work independently for extended periods
-- **Context-aware assistance** with deep understanding of your codebase
-- **AWS service integration** with native support for CDK, SAM, and Terraform
-- **MCP (Model Context Protocol)** for secure external API and database calls
-- **Spec-driven development** that turns natural language into structured specifications
-## Why Use Skills with Kiro?
-Kiro's agentic capabilities are enhanced by skills that provide:
-- **Domain expertise** across 2,111+ 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
-## Installation
-### Quick Install
-```bash
-# Install to Kiro's default skills directory
-npx agentic-awesome-skills --kiro
-```
-This installs skills to `~/.kiro/skills/`
-### Manual Installation
-```bash
-# Clone directly to Kiro's skills directory
-git clone https://github.com/sickn33/agentic-awesome-skills.git ~/.kiro/skills
-```
-### Verification
-```bash
-# Verify installation
-test -d ~/.kiro/skills && echo "✓ Skills installed successfully"
-ls ~/.kiro/skills/ | head -10
-```
-## Using Skills with Kiro
-### Basic Invocation
-Kiro uses natural language prompts to invoke skills:
-```
-Use the @brainstorming skill to help me design a serverless API
-```
-```
-Apply @aws-serverless patterns to this Lambda function
-```
-```
-Run @security-audit on my CDK stack
-```
-### Recommended Skills for Kiro Users
-#### AWS & Cloud Infrastructure
-- `@aws-serverless` - Serverless architecture patterns
-- `@aws-cdk` - AWS CDK best practices
-- `@aws-sam` - SAM template patterns
-- `@terraform-expert` - Terraform infrastructure as code
-- `@docker-expert` - Container optimization
-- `@kubernetes-expert` - K8s deployment patterns
-#### Architecture & Design
-- `@architecture` - System design and ADRs
-- `@c4-context` - C4 model diagrams
-- `@senior-architect` - Scalable architecture patterns
-- `@microservices-patterns` - Microservices design
-#### Security
-- `@api-security-best-practices` - API security hardening
-- `@vulnerability-scanner` - Security vulnerability detection
-- `@owasp-top-10` - OWASP security patterns
-- `@aws-security-best-practices` - AWS security configuration
-#### Development
-- `@typescript-expert` - TypeScript best practices
-- `@python-patterns` - Python design patterns
-- `@react-patterns` - React component patterns
-- `@test-driven-development` - TDD workflows
-#### DevOps & Automation
-- `@ci-cd-pipeline` - CI/CD automation
-- `@github-actions` - GitHub Actions workflows
-- `@monitoring-observability` - Observability patterns
-- `@incident-response` - Incident management
-## Kiro-Specific Workflows
-### 1. Serverless Application Development
-```
-1. Use @brainstorming to design the application architecture
-2. Apply @aws-serverless to create Lambda functions
-3. Use @aws-cdk to generate infrastructure code
-4. Run @test-driven-development to add tests
-5. Apply @ci-cd-pipeline to set up deployment
-```
-### 2. Infrastructure as Code
-```
-1. Use @architecture to document the system design
-2. Apply @terraform-expert to write Terraform modules
-3. Run @security-audit to check for vulnerabilities
-4. Use @documentation to generate README and runbooks
-```
-### 3. API Development
-```
-1. Use @api-design to plan endpoints
-2. Apply @typescript-expert for implementation
-3. Run @api-security-best-practices for hardening
-4. Use @openapi-spec to generate documentation
-```
-## Advanced Features
-### MCP Integration
-Kiro's MCP support allows skills to:
-- Call external APIs securely
-- Query databases with context
-- Integrate with AWS services
-- Access documentation in real-time
-Skills that leverage MCP:
-- `@rag-engineer` - RAG system implementation
-- `@langgraph` - Agent workflow orchestration
-- `@prompt-engineer` - LLM prompt optimization
-### Autonomous Operation
-Kiro can work independently for extended periods. Use skills to guide long-running tasks:
-```
-Use @systematic-debugging to investigate and fix all TypeScript errors in the codebase,
-then apply @test-driven-development to add missing tests, and finally run @documentation
-to update all README files.
-```
-### Context-Aware Assistance
-Kiro maintains deep context. Reference multiple skills in complex workflows:
-```
-I'm building a SaaS application. Use @brainstorming for the MVP plan,
-@aws-serverless for the backend, @react-patterns for the frontend,
-@stripe-integration for payments, and @security-audit for hardening.
-```
-## Bundles for Kiro Users
-Pre-curated skill collections optimized for common Kiro use cases:
-### AWS Developer Bundle
-- `@aws-serverless`
-- `@aws-cdk`
-- `@aws-sam`
-- `@lambda-best-practices`
-- `@dynamodb-patterns`
-- `@api-gateway-patterns`
-### Full-Stack AWS Bundle
-- `@aws-serverless`
-- `@react-patterns`
-- `@typescript-expert`
-- `@api-design`
-- `@test-driven-development`
-- `@ci-cd-pipeline`
-### DevOps & Infrastructure Bundle
-- `@terraform-expert`
-- `@docker-expert`
-- `@kubernetes-expert`
-- `@monitoring-observability`
-- `@incident-response`
-- `@security-audit`
-See [bundles.md](bundles.md) for complete bundle listings.
-## Troubleshooting
-### Skills Not Loading
-```bash
-# Check installation path
-ls -la ~/.kiro/skills/
-# Reinstall if needed
-rm -rf ~/.kiro/skills
-npx agentic-awesome-skills --kiro
-```
-### Skill Not Found
-Ensure you're using the correct skill name:
-```bash
-# List all available skills
-ls ~/.kiro/skills/
-```
-### Permission Issues
-```bash
-# Fix permissions
-chmod -R 755 ~/.kiro/skills/
-```
-## Best Practices
-1. **Start with bundles** - Use pre-curated collections for your role
-2. **Combine skills** - Reference multiple skills in complex tasks
-3. **Be specific** - Clearly state which skill to use and what to do
-4. **Iterate** - Let Kiro work autonomously, then refine with additional skills
-5. **Document** - Use `@documentation` to keep your codebase well-documented
-## Examples
-### Example 1: Build a Serverless API
-```
-I need to build a REST API for a todo application using AWS Lambda and DynamoDB.
-Use @brainstorming to design the architecture, then apply @aws-serverless
-to implement the Lambda functions, @dynamodb-patterns for data modeling,
-and @api-security-best-practices for security hardening.
-Generate the infrastructure using @aws-cdk and add tests with @test-driven-development.
-```
-### Example 2: Migrate to Microservices
-```
-I want to break down this monolithic application into microservices.
-Use @architecture to create an ADR for the migration strategy,
-apply @microservices-patterns for service boundaries,
-@docker-expert for containerization, and @kubernetes-expert for orchestration.
-Document the migration plan with @documentation.
-```
-### Example 3: Security Audit
-```
-Perform a comprehensive security audit of this application.
-Use @security-audit to scan for vulnerabilities, @owasp-top-10 to check
-for common issues, @api-security-best-practices for API hardening,
-and @aws-security-best-practices for cloud configuration.
-Generate a report with findings and remediation steps.
-```
-## Resources
-- [Kiro Official Documentation](https://kiro.dev)
-- [AWS Blog: Transform DevOps with Kiro](https://aws.amazon.com/blogs/publicsector/transform-devops-practice-with-kiro-ai-powered-agents/)
-- [Complete Skills Catalog](../../CATALOG.md)
-- [Usage Guide](usage.md)
-- [Workflow Examples](workflows.md)
-## Contributing
-Found a Kiro-specific use case or workflow? Contribute to this guide:
-1. Fork the repository
-2. Add your examples to this file
-3. Submit a pull request
-## Support
-- **Issues**: [GitHub Issues](https://github.com/sickn33/agentic-awesome-skills/issues)
-- **Discussions**: [GitHub Discussions](https://github.com/sickn33/agentic-awesome-skills/discussions)
-- **Community**: [Community Guidelines](../contributors/community-guidelines.md)

package/bundled-skills/docs/users/local-config.md DELETED Viewed

@@ -1,152 +0,0 @@
-# Local Skills Configuration Snapshot
-> **Historical snapshot**: This page preserves an older 35-skill local configuration recommendation from 2026-01-16. It is not the current repository catalog.
-> **Current catalog**: Use [`../../skills_index.json`](../../skills_index.json), [`../../CATALOG.md`](../../CATALOG.md), or the installer filters in the README for the active 1,684+ skill library.
-## 📊 Recommended High-Priority Skills (35)
-These are the skills recommended for most common development workflows. All other skills remain available and can be used as needed.
-### 🔥 Tier S - Core Development (13 skills)
-Essential skills used automatically by the agent:
-- `systematic-debugging` - Root cause analysis and structured debugging
-- `test-driven-development` - TDD workflow and red-green-refactor
-- `writing-skills` - Documentation and markdown expertise
-- `doc-coauthoring` - Structured technical documentation workflow
-- `planning-with-files` - Implementation plan creation
-- `concise-planning` - Fast planning for small tasks
-- `software-architecture` - Quality-focused design principles
-- `senior-architect` - Scalable system design and architecture
-- `senior-fullstack` - Full-stack development best practices
-- `verification-before-completion` - Pre-completion verification workflow
-- `git-pushing` - Automated staging and conventional commits
-- `address-github-comments` - Systematic code review response workflow
-- `javascript-mastery` - Advanced JavaScript patterns
-### ⭐ Tier A - Your Projects (12 skills)
-Skills actively used for your specific projects:
-- `docx-official` (+ symlink `docx`) - Official Anthropic Word manipulation
-- `pdf-official` (+ symlink `pdf`) - Official Anthropic PDF manipulation
-- `pptx-official` (+ symlink `pptx`) - Official Anthropic PowerPoint manipulation
-- `xlsx-official` (+ symlink `xlsx`) - Official Anthropic Excel manipulation
-- `react-best-practices` - Vercel's 40+ performance optimization rules
-- `web-design-guidelines` - Vercel's 100+ UI/UX audit rules
-- `frontend-dev-guidelines` - Modern React/TS development patterns
-- `webapp-testing` - Local web application testing with Playwright
-- `playwright-skill` - Advanced Playwright automation
-- `mcp-builder` - Model Context Protocol server creation
-- `notebooklm` - Google NotebookLM integration
-- `ui-ux-pro-max` - Advanced design intelligence
-### 📢 Marketing & SEO (1 skill)
-- `content-creator` - SEO-optimized marketing and brand voice
-### 🏢 Corporate (4 skills)
-- `brand-guidelines-anthropic` - Official Anthropic brand styling
-- `brand-guidelines-community` - Community brand guidelines
-- `internal-comms-anthropic` - Official Anthropic communications
-- `internal-comms-community` - Community communications
-### 📝 Planning & Documentation (1 skill)
-- `writing-plans` - Strategic planning documentation
-### 🤖 AI & Automation (5 skills)
-- `workflow-automation` - AI-native workflow automation and API integration
-- `llm-app-patterns` - Design patterns for LLM applications
-- `autonomous-agent-patterns` - Patterns for autonomous agents
-- `prompt-library` - Curated collection of optimized prompts
-- `github-workflow-automation` - GitHub Actions and CI/CD automation
----
-## 🗂️ Snapshot Structure
-```
-local snapshot/
-├── [96 active skills in this snapshot]
-└── [4 symlinks in this snapshot]
-```
----
-## 📚 Other Snapshot Skills (61)
-All other skills in the repository are available for use as needed. Some notable categories:
-### Security & Penetration Testing (34 skills)
-For security professionals and pentesting:
-- AWS, Cloud, Network penetration testing
-- Web vulnerabilities (XSS, SQL injection, IDOR, etc.)
-- Security tools (Burp Suite, Metasploit, SQLMap, Wireshark, etc.)
-- Privilege escalation (Windows, Linux)
-- Active Directory attacks
-### Development & Testing (7 skills)
-Additional development tools:
-- `backend-dev-guidelines`, `test-fixing`, `testing-patterns`
-- `receiving-code-review`, `requesting-code-review`
-- `react-ui-patterns`, `frontend-design`
-### Creative & Design (5 skills)
-Specialized creative tools:
-- `theme-factory`, `canvas-design`, `algorithmic-art`
-- `claude-d3js-skill`, `slack-gif-creator`
-### Workflow & Architecture (7 skills)
-Advanced workflows:
-- `loki-mode` (1093 files - very comprehensive autonomous agent mode)
-- `brainstorming`, `executing-plans`, `file-organizer`
-- `kaizen`, `using-git-worktrees`, `using-superpowers`
-### Business & Product (3 skills)
-Product management:
-- `app-store-optimization`, `product-manager-toolkit`
-- `prompt-engineering`
-### Infrastructure (2 skills)
-System administration:
-- `linux-shell-scripting`, `bun-development`
-### Other (3 skills)
-Miscellaneous:
-- `skill-creator`, `skill-developer`, `core-components`
-- `web-artifacts-builder`, `subagent-driven-development`
-- `dispatching-parallel-agents`, `finishing-a-development-branch`
----
-## 🎯 Benefits of This Recommendation
-✅ **Focused Guidance** - 35 high-priority skills for common workflows
-✅ **Snapshot Availability** - All 96 skills from this older local set were accessible when needed
-✅ **Balanced Coverage** - Core dev + AI/automation + frontend excellence
-✅ **Easy Discovery** - Categorized list of all other available skills
----
-**Snapshot Date**: 2026-01-16
-**Recommended Skills**: 35 high-priority
-**Snapshot Total**: 96 skills + 4 symlinks = 100 total
-**Recent Additions to Recommendations**: `senior-fullstack`, `concise-planning`, `address-github-comments`, `javascript-mastery`, `workflow-automation`, `llm-app-patterns`, `autonomous-agent-patterns`, `prompt-library`