thehardwarestore.ai

This repository is a curated 'awesome list' and comprehensive documentation hub for the Agent Skills ecosystem. It does not contain any executable application code, data pipelines, or machine learning models. Instead, it serves as a static directory of links to official projects (Anthropic, OpenAI, Google, Vercel, etc.), community-contributed skills, tutorials, and best-practice guides. The core value lies in its translated and aggregated documentation, including detailed guides on Skill design patterns, practical experience from Anthropic, and a complete build guide. It is a reference resource, not a software tool. Engineers and AI agents should use this repo to discover the Agent Skills specification, find relevant skills to install, and learn how to create their own. It is not a library or framework to be imported.

This repository is a collection of Claude/Anthropic skills and platform documentation rather than a standalone application. It contains skill definitions (SKILL.md files), MCP server evaluation guidance, managed-agents documentation, and supporting tooling such as schema definitions and build scripts. The dominant character is developer-facing content and reusable patterns for building LLM agents, with some executable scripts for validation and report generation. It provides structured output schemas for evaluation pipelines (grading, benchmark, comparison, analysis), a validator hierarchy for XML/XSD-based skill files, and a security-conscious file I/O example in build-report-lite.mjs. It also documents managed agents, platform availability, and MCP best practices. The repository is not a data research project; there are no notebooks, data pipelines, or model training scripts. Maintenance is active, but technical drift is medium due to version-sensitive SDK references, manually maintained platform availability tables, and multiple language-specific examples that must be kept in sync. The code and schemas are generally well-structured and reusable, though some paths are hardcoded and some documentation is tightly coupled to generator scripts.

This repository implements a production-grade Google Maps business data extraction platform with multiple execution modes: CLI, web UI, REST API, AWS Lambda, and a self-hosted SaaS edition. The core scraping engine uses Playwright for browser automation and also supports a stealth HTTP fast mode. It extracts 36+ structured fields per business (name, address, phone, website, reviews, ratings, emails, coordinates, hours, etc.) and provides deduplication, grid-based area coverage, email extraction via website visits, and review parsing. The architecture is modular with packages for scraping jobs, runners (file, database, web, Lambda, SaaS worker), output writers (CSV, JSON, PostgreSQL, S3, custom plugins), job queuing via River, and a comprehensive admin dashboard with cloud provisioning on DigitalOcean and Hetzner. The system is designed for both single-user CLI use and multi-tenant SaaS deployments with authentication, 2FA, API key management, and scalable worker pools. The codebase demonstrates strong Go engineering practices with well-defined interfaces, dependency injection, and test coverage. Notable reusable components include cryptography utilities, HTTP server middleware, rate limiting, and a CLI prompt library. However, the repository has some maintenance concerns: two separate database migration sets for legacy and SaaS modes, in-memory deduplication that doesn't persist across restarts, committed test SSH keys in the `local/` directory, and a large dependency surface that could introduce version conflicts. The scraper logic is inherently brittle due to reliance on Google Maps internal data structures, which are subject to change without notice. For AI agent consumption: This is a powerful off-the-shelf scraping tool that can be deployed as a Docker container, AWS Lambda, or managed SaaS. It provides a complete API and web interface for managing scraping jobs, monitoring progress, and exporting data. The SaaS edition includes worker auto-provisioning, making it suitable for large-scale lead generation operations. The code is actively maintained with recent commits addressing performance and feature enhancements.

PageEyes Agent is a production-grade Python framework for natural-language-driven UI automation, published on PyPI as `page-eyes` (v1.3.9). It provides LLM agents that perceive screens and execute actions (click, input, swipe, assert) across Web (Playwright), Android (ADB), iOS (WebDriverAgent), HarmonyOS (hdc), and Electron (CDP). The core architecture separates a PlanningAgent that decomposes user instructions into atomic steps from per-platform execution agents that call tools through Pydantic AI's tool-calling framework. Screen perception is delegated either to a vision-language model in lightweight mode or to the bundled OmniParser2 service in full mode. Each run produces a self-contained HTML report with step logs, screenshots, element bounding-box overlays, and video, which can be uploaded to COS or MinIO. The repo is hybrid: it is primarily an application framework but embeds a significant ML-serving sub-project, OmniParser2, which is a FastAPI microservice running PaddleOCR for text detection, a fine-tuned YOLOv11n for icon detection, a LoRA-fine-tuned Florence-2 model for icon captioning, and a YOLO overlay detector for popups/loading states, with optional Milvus-based image caching. Model weights and tokenizer artifacts (including a ~96k-token BPE merges file) are committed to the repository, and the docs include detailed articles on Florence-2 LoRA fine-tuning and YOLO overlay detection, giving the repo a data-research flavor alongside its application character. The codebase shows genuine engineering skill: a generic Device abstraction with factory methods, a storage strategy pattern (COS/MinIO/Base64), a reusable skills system (e.g., gui-popup-handler), and an agent loop with planning/execution/reflection separation. CI/CD, tests, a changelog, and mkdocs documentation are present. Weaknesses include heavy ML dependencies with override conflicts, a committed binary blob (yadb), code duplication between the main package and OmniParser2, and coupling to Tencent-internal infrastructure (mirror URLs, email addresses, platform names), which limits external portability.

Agentic Awesome Skills is a curated marketplace infrastructure for AI coding agent skills—instructional playbooks (SKILL.md files) with accompanying scripts and assets. The repository provides a multi-platform distribution system supporting Claude Code, Cursor, Gemini CLI, Codex CLI, Kiro, and others. It includes a React+Vite web application for browsing, searching, and installing skills; a CLI and MCP server for local agent integration; and a comprehensive validation, security scanning, and release pipeline. The codebase implements a transaction engine with deterministic content addressing (canonical JSON + SHA-256), durable state management, and schema-validated skill installation, forming a robust foundation for agent-owned tool selection and workflow planning. While the core infrastructure (AAS v1 library, MCP server, catalog search) demonstrates high craftsmanship and reusability, the repository is hampered by massive file duplication: identical skill scripts and governance modules appear under `skills/`, `plugins/agentic-awesome-skills/`, and `plugins/agentic-awesome-skills-claude/`, creating synchronization risk. Some skills contain hardcoded paths or incomplete boilerplate. The repository is actively maintained with CI/CD, automated audits, and security scrutiny, though the sheer volume of 2,474+ skills imposes ongoing maintenance burden. Overall, it is a well-engineered, production-quality skill distribution platform with notable reusable design patterns.

AutoSkill is a comprehensive framework for extracting, managing, and evolving reusable 'skills' from conversational logs and documents. It operates as a modular application with multiple entry points: a web UI for interactive chat, a CLI for batch processing, and an OpenAI-compatible proxy server that injects relevant skills into LLM context. The system employs LLM-driven and heuristic pipelines to extract skill candidates, deduplicate and merge them, and persist them in a skill store with vector and BM25 retrieval. It also includes a self-evolution subsystem (SkillEvo) that replays experiences, evaluates performance, and mutates skills for improvement. The codebase is hybrid, containing both application components (web server, proxy, libraries) and data/research pipelines (document ingestion, trajectory extraction), but the dominant character is an application SDK designed for integration with agentic workflows. Notable craftsmanship is seen in standalone utilities like a CJK-aware text unit counter, an AST-based prompt patcher, a persistent BM25 index, and a LibreOffice socket shim, though the repo also suffers from significant code duplication (e.g., identical validators across docx/pptx/xlsx) and a large surface area of environment variables and external dependencies.

This repository is the NVIDIA BioNeMo Agent Toolkit — a collection of 31 skills that give coding/scientific agents (Claude Code, Codex, any SKILL.md-compatible harness) domain knowledge for life-science workflows: protein structure prediction, molecular docking, generative chemistry, and related tasks. Skills execute in the user's own environment (workstation, notebook, cluster) and wrap NVIDIA NIM (NVIDIA Inference Microservices) APIs — both hosted endpoints and local Docker deployments. The toolkit is not an installable Python package; it is a skill catalog with supporting tooling, dual-licensed (Apache-2.0 OR CC-BY-4.0).

Nova Proximity is a modular Python security scanner designed specifically for MCP (Model Context Protocol) servers and Agent Skills. The application provides comprehensive discovery and analysis capabilities, including tool/prompt/resource enumeration for MCP servers and structural/permission analysis for Agent Skills. Its architecture separates concerns into distinct libraries: mcp_scanner_lib for MCP protocol handling, skill_scanner_lib for Agent Skills analysis, and nova_evaluator_lib for NOVA-powered security evaluation. The tool supports multiple transport mechanisms (stdio, SSE, Streamable HTTP) with automatic fallback, provides detailed function signature analysis, and generates actionable security reports with pattern-specific remediation guidance.

This repository is a collection of Agent Skills for AI coding assistants (Claude Code, Codex, OpenCode) that enables them to interact with Obsidian vaults. It contains six skill definitions: obsidian-markdown (creating Obsidian Flavored Markdown with wikilinks, embeds, callouts, properties), obsidian-bases (creating database-like .base files with views, filters, formulas), json-canvas (creating visual .canvas files with nodes and edges), obsidian-cli (interacting with Obsidian via CLI for note management and plugin development), defuddle (extracting clean markdown from web pages), and knap (rendering Markdown templates from structured data). Each skill is a self-contained markdown file following the Agent Skills specification, providing detailed syntax, examples, and validation steps. The repository is purely documentation with no executable code, serving as a knowledge base that AI agents use to perform Obsidian-related tasks on behalf of users.

This repository is a content-based Claude Code skill package rather than a conventional software service. It contains two agent skills — /tutor-setup and /tutor — that an LLM coding assistant executes using filesystem and WebFetch tools. tutor-setup scans a working directory, auto-detects whether it contains source code or documents, and generates an Obsidian StudyVault: concept notes, dashboards, exam-traps, and practice questions, with strict rules for source traceability, tag registries, wiki-linking, and folder conventions. tutor-setup operates through detailed phase models (D1-D9 for documents, C1-C9 for codebases), and codebase mode produces architecture maps, module notes, API surfaces, and onboarding exercises. tutor then reads that vault and runs interactive 4-question quiz rounds, updating concept-level progress files and a compact dashboard; it supports diagnostic, weak-area drill, section review, and hard-mode sessions, all governed by a zero-hint quiz design rule in references/quiz-rules.md. The implementation is almost entirely Markdown instructions plus two small Bash install/uninstall scripts; there is no compiled code, test suite, CI pipeline, or dependency manifest. The operational logic is prompt/instruction engineering that Claude Code interprets. External dependencies are Claude Code (or a compatible npx-skills-aware assistant), Obsidian for reviewing generated vaults, pdftotext/poppler for PDF extraction, and the assistant's built-in Read, Write, Edit, Glob, Grep, Bash, WebFetch, and AskUserQuestion tools. The data flow is unidirectional: source files in the CWD are scanned and extracted, transformed into StudyVault markdown, then quiz answers update concept files and dashboard aggregate stats. The skill enforces a CWD boundary to avoid accessing files outside the working directory. The strong point is unusually detailed and internally consistent procedural specification: mandatory source-content verification, per-topic coverage rules, tag registries, active-recall fold callouts, interlinking requirements, and self-review quality checklists. Weaknesses are the absence of automated tests/CI and versioned dependency pins, and behavior ultimately depends on the host LLM following prompt rules correctly. The README also references a different GitHub owner (RoundTable02) than the repository path (bevibing/tutor-skills), indicating a fork or repackage whose provenance should be verified before use. Overall, it fulfills its stated purpose well, and several Markdown modules are genuinely reusable as templates for other agent skills, study-vault generators, or adaptive quiz systems.

Violin is an open-source video dubbing application that transcribes speech from any video, translates it into one of 33 languages, synthesizes a native-sounding voice-over using TTS (Cartesia Sonic 3, ElevenLabs, or OpenAI), and remuxes the result into a new video with optional SRT subtitles and in-video Q&A. The system provides three interfaces: a CLI tool (`violin <input> <output> --language <lang>`), a FastAPI web application with a browser UI for upload/download and real-time polling, and a Claude Code skill for invocation from a Claude session. The architecture follows a five-stage pipeline (audio extraction → Whisper transcription → LLM translation → TTS synthesis → video/audio merging with speed alignment) orchestrated by a shared `dub_video` function. Both the CLI and the API worker call the same core pipeline, with parameterized callbacks for progress reporting and cancellation. The API supports bring-your-own-key (BYOK) or server-provided free trial, job persistence via the filesystem, SQLite-based usage statistics, and periodic cleanup of stale jobs and orphaned temp directories. Configuration is YAML-based with deep-merge defaults, supporting pluggable providers per stage. The codebase is well-structured with separate modules for each pipeline stage, reusable cost tracking, and a prompt management system with safe format interpolation. Notable craftsmanship includes the `CostTracker` dataclass for per-job wall-clock and dollar-cost telemetry, the `transcriber.py` segment merging/deduplication logic for Whisper output, and the `api/stats.py` SQLite-backed stats with schema migration. The main weaknesses are the absence of unit tests (no test directory found) and some internal coupling of pipeline components to the global config object. The monolithic SPA frontend is functional but not independently reusable.

This repository is a curated collection of Claude skills—markdown instructions and supporting scripts that enable Claude (or any MCP-compatible agent) to perform a wide range of tasks, from document manipulation (DOCX, PPTX, PDF, XLSX) and GIF animation to web testing, MCP server building, and automation of hundreds of third-party SaaS services via Composio's Rube MCP. The repo is primarily a skill library with a standardized template for each skill, but it also contains several well-crafted Python libraries (e.g., easing functions, particle systems, OOXML validation frameworks) that are genuinely reusable. The architecture is modular: each skill lives in its own directory with a SKILL.md and optional scripts. The heavy reliance on external services (Composio, Rube MCP) and the massive duplication of templated skill documentation introduce maintenance risks, but the core utility scripts demonstrate solid engineering craftsmanship.

SenseNova-Skills is a composable collection of AI agent skills for office automation, built around the SenseNova model family. It provides production-grade capabilities for image generation and recognition, presentation (PPT) creation, Excel data analysis, deep research with structured evidence, and multi-source search (academic, social, code, finance). The skills are designed to run in Agent Skills-compatible runtimes (OpenClaw, hermes-agent) and are bundled into the Raccoon product for enterprise use. The architecture is modular: each skill is a self-contained directory with a SKILL.md manifest, scripts, prompts, and schemas. The deep research skill implements a multi-agent pipeline with formal JSON schemas and validators. The PPT skill has a multi-stage pipeline from user input to HTML-to-PPTX conversion via Playwright. The codebase demonstrates solid engineering with reusable components like a shared LLM/VLM client, export pipeline libraries, and validation infrastructure. However, it suffers from duplicated utility code across skills, complex environment variable fallback chains, hardcoded paths, and dependency on external APIs and headless browsers. The repo is actively maintained with biweekly reports and frequent commits.

This repository is a collection of AI agent skill definitions for the Higgsfield platform, enabling automated content creation across multiple domains including brand identity, product photography, website generation, video explainers, YouTube thumbnails, and 3D game assets. Each skill is self-contained in a folder with a SKILL.md entry point and references directory, designed for consumption by AI agents (Claude, Cursor, Codex). The repo also includes deterministic scripts for GLB processing, texture pipeline, procedural rigging, and brandbook generation, as well as CI validation workflows. While primarily a skill library, it contains reusable engineering patterns such as a brandkit state machine, stdlib-only GLB patching, and a texture seam-fix pipeline. The codebase is well-structured with version sync enforcement and anti-slop design rules, but relies on external tools (Blender, ImageMagick, LibreOffice) and live Higgsfield API endpoints.

This repository implements a meta-skill (ex-skill) that generates digital personas of former romantic partners by analyzing chat histories from WeChat and iMessage. It is designed to be consumed by AI agent runtimes like OpenClaw, Claude Code, or DeepSeek Harness via the AgentSkills standard. The system guides users through conversational intake of relationship details (astrology, MBTI, attachment style), automatically decrypts and extracts WeChat/iMessage chat databases, analyzes communication patterns using LLM prompt templates, and writes a structured persona skill that can be interactively chatted with. The codebase consists of a SKILL.md orchestrator, six detailed LLM prompts (intake, analysis, persona builder, merger, correction handler), four Python tools (database decryption, message parsing, skill file management, version management), and an example persona. It is a specialized tool for cyber-immortality and digital persona creation, blending reverse engineering with psychological profiling.

This repository is a curated collection of prompt templates and agent skill configurations for AI-assisted academic writing. It contains no executable code, only a single README.md file that documents prompts for translation, polishing, logic checking, and figure/table caption generation, as well as instructions for configuring agent skills in tools like Cursor. The prompts are designed for use with large language models to help researchers write and refine papers. While the content is well-organized and practical, the repository is purely documentation with no software implementation, making it a reference resource rather than a functional application.

This repository is a curated 'awesome list' of links to external Agent Skills repositories. It contains no application code, data pipelines, or executable software. Its sole function is to serve as a community-maintained index and directory. The README is meticulously organized by vendor and category, with contribution guidelines, quality standards, and a security notice. While it has no software components to extract, it is a highly effective and well-maintained directory for its domain. It is not a software application and has zero reusability as a codebase.