thehardwarestore.ai

This repository is a comprehensive operational playbook for 'Ralph', Geoff Huntley's methodology for running Claude Code in an autonomous loop to build software. The core deliverable is a detailed guide (README.md plus a styled index.html mirror) explaining the three-phase workflow: define requirements as JTBD-aligned specs, generate an implementation plan via a planning loop, then run a building loop where Claude picks tasks from the plan, implements them, validates against tests, and commits — with a fresh context window per iteration. The guide is unusually well-structured, covering context management, backpressure via tests, sandbox security, and tuning strategies. Beyond documentation, the repo ships functional artifacts: two bash loop scripts (files/loop.sh, files/loop_streamed.sh) that orchestrate the Claude CLI, a dependency-free Node.js stream parser (files/parse_stream.js) for readable terminal output, and five prompt templates (PROMPT_build.md, PROMPT_plan.md, PROMPT_specs.md, PROMPT_reverse_engineer_specs.md) encoding the methodology's guardrails. It also documents sandbox environment options (E2B, Fly Sprites, Modal, Cloudflare, Docker) for safely running autonomous agents with --dangerously-skip-permissions. The prompt templates are the real product — they encode hard-won operational knowledge about context efficiency, subagent fan-out, and steering LLM behavior. Notable patterns include escalating 9s-numbered guardrails, explicit subagent limits (500 for search, 1 for build/tests), the 'one sentence without and' topic scoping test, and a two-phase reverse-engineering prompt that produces implementation-free behavioral specs. This is a documentation-first repo with a small but functional code footprint.

Claude Delegator is a Claude Code plugin that provides GPT (via Codex CLI) and Gemini (via Gemini CLI) as specialized expert subagents. It offers five domain experts (Architect, Plan Reviewer, Scope Analyst, Code Reviewer, Security Analyst) that can advise or implement based on task requirements. The plugin uses MCP (Model Context Protocol) to connect to external CLIs, featuring sophisticated delegation logic with proactive triggers, session management (single-shot and multi-turn), and response synthesis. A key innovation is the zero-dependency Gemini MCP bridge that wraps the Gemini CLI in a standard MCP interface.

Agent OS is a framework for AI coding assistants to establish, discover, and inject project standards and shape specifications. It provides a set of markdown commands (commands/agent-os/) that define workflows for common tasks like discovering codebase patterns, maintaining an index of standards, injecting relevant standards into context, planning product vision, and shaping feature specs. These commands are designed to be consumed by tools like Claude Code and Cursor. The repository also includes bash scripts for installing Agent OS into a project, syncing standards back to a base profile, and shared utility functions. The core value is not executable code but a methodology encoded in instructions and shell scripts that enforce a disciplined approach to spec-driven development with AI agents. The codebase is lean, well-structured, and focused on solving the problem of keeping AI agents aligned with team conventions without heavy tooling overhead.

This repository is a comprehensive plugin and skill set for Claude Code (and compatible CLI assistants like Codex CLI and OpenCode), designed to transform the AI into a semi-automated research assistant for academic and software development workflows. It is not a standalone application but a configuration package that installs skills, commands, agents, hooks, and rules into the user's Claude environment. The architecture follows a skill-based pattern: each skill is a directory with a SKILL.md entry point, references, examples, and optional scripts, all consumed by the AI at runtime. The repository covers the full research lifecycle—ideation, literature review (via Zotero MCP and arXiv APIs), experiment analysis, ML paper writing with conference-specific LaTeX templates (NeurIPS, ICLR, ICML, ACL, AAAI), reviewer response drafting, publication chart creation, and post-acceptance promotion. It also integrates deeply with Obsidian for project knowledge management and includes a meta-toolchain for developing and QA-ing skills themselves. While primarily an application configuration, it contains substantial research-oriented content (Kaggle competition analyses, citation verification workflows, writing pattern references), making it a hybrid tool that bridges software engineering and data science research. The codebase is actively maintained, well-documented, and demonstrates strong craftsmanship in its script utilities and hook infrastructure.

This repository is a comprehensive, tool-agnostic skills and steering pack that teaches AI coding agents to perform AWS Well-Architected Framework reviews. It contains a curated reference corpus of over 2,000 markdown files (6 pillars, 307 best practices, 27 industry lenses) derived from official AWS documentation, plus per-tool adapters for 15 AI coding assistants (Claude Code, Cursor, Codex, GitHub Copilot, etc.). The repo also ships production-grade supporting tooling: a CI gating tool (wa-ci) that diffs structured review JSON against a baseline and blocks PRs on regressed gaps; an evaluation harness with blind multi-reviewer adversarial adjudication; a crawler to regenerate the reference corpus from AWS docs; and one-command installers. The core skill dispatches six parallel subagents (one per pillar) to keep the 2.2 MB corpus out of any single context window. Despite the extensive content, the repository has notable maintenance challenges: the reference snapshot will drift as AWS documentation evolves (users are responsible for regeneration); lens files are duplicated across `powers/` and `skills/` directories creating a sync hazard; and the flagship skill is explicitly deprecated in favor of a successor in Agent Toolkit for AWS. The evaluation harnesses and CI tooling are well-crafted and reusable, but the sheer scale of markdown files and platform-specific adapters makes ongoing synchronization complex.

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.

This repository provides a collection of 52 specialized AI agent definitions for penetration testing and red team operations, designed to be used with Claude Code. It is distributed as a Claude Code plugin, with an interactive installer (install.sh), a SQLite findings database (db/findings.sh) for persisting engagement data, and a versioned migration system. The agents are defined as Markdown files with YAML frontmatter, each containing structured system prompts that enforce scope validation, OPSEC tagging, evidence handling, and MITRE ATT&CK mapping. The system includes a swarm orchestrator for multi-agent coordination, a scope guard for safety, and a two-tier safety model (advisory vs. Bash-capable agents). While primarily a configuration/instruction set rather than a traditional software application, it demonstrates strong engineering practices in prompt architecture, database schema design, and distribution automation. The repository is actively maintained with CI validation, shellcheck, and unit tests for the database scripts.

This is a Claude Code plugin and resource library, not a deployable application or data pipeline: 27 slash commands, 9+ autonomous skills, 3 auditor subagents, and extensive prompt-engineering documentation that extend the Claude Code CLI. In production, the system functions as configuration-as-code content consumed by the Claude Code runtime — teaching the assistant how to create executable plans (PLAN.md is the prompt itself), chain meta-prompts, build MCP servers, manage subagent orchestration, run autonomous coding loops (the 'Ralph' technique), and apply iOS/macOS development expertise. The only real executable code is a handful of self-contained scripts: a TypeScript CLI for The Pirate Bay API, Python/TypeScript MCP server templates, project scaffolding shell scripts, and autonomous loop iteration scripts. The dominant architectural pattern is the 'router skill': a SKILL.md entry point with essential principles, an intake gate, a routing table, and progressive disclosure into workflows, references, templates, and scripts — implemented consistently across all skills with pure XML prompt structure and checkpoint-based plan execution. Despite being classified as an application (there is no data-research character — no notebooks, datasets, or pipelines), its substance is largely authored content rather than software. The craft is strong: consistent XML schemas across files, a genuine QA layer (skill-auditor agents), secret hygiene practices, and a well-developed checkpoint/auth-gate protocol for safe automation. However, the repo carries real drift risks: duplicated reference files (research-pitfalls.md, cli-observability.md are copied across skills), dangling references to not-yet-created files, tight coupling to Claude Code's evolving plugin API, version-specific Apple platform guidance that will age, and the included The Pirate Bay skill which depends on a fragile third-party API and presents a content-policy concern. An engineer seeking to reuse this should extract the self-contained templates and scripts (MCP server scaffolding, loop automation) and treat the reference material as opinionated prompt guidance rather than canonical documentation.

This repository is a motion-graphics video production toolkit designed for AI coding assistants (Codex and Claude Code). It provides a structured pipeline for turning talking-head footage into edited videos with animated overlays, using HTML/CSS/JS compositions driven by GSAP timelines. The system includes reusable style libraries (Vox Explainer and Kallaway) with hundreds of parameterized card templates, transcription and cut-detection scripts, beat-planning heuristics, and project scaffolding. The architecture is a collection of standalone Node.js scripts, agent skill definitions, and HTML templates rather than a monolithic application. It relies on external services (ElevenLabs, Kie.ai, HyperFrames CLI) and CDN-hosted libraries (GSAP, Google Fonts). The repo is actively maintained with recent commits and a CI pipeline, though it exhibits some duplication between mirrored skill directories and draft-status cards that have not all been individually rendered.

This repository is a Python library and Claude Code plugin for generating McKinsey-style PowerPoint (PPTX) presentations. It provides ~40 slide templates (executive summaries, charts, matrices, org charts, roadmaps, etc.) with a consistent deep-navy/bright-blue design system. The core architecture is a builder pattern: `PresentationBuilder` accepts slide specs (as dicts or keyword arguments) and delegates to slide-specific drawing functions in the `slides/` subpackage. A CLI (`mckinsey_pptx.cli`) reads JSON specs and produces `.pptx` files. The Claude Code integration includes an agent definition (`mckinsey-slide-agent.md`) that reads a template catalog, plans a deck story arc, generates a Python build script, executes it, and optionally renders PNG previews via LibreOffice/Poppler. The code is well-structured with a clean separation of concerns: theme dataclasses, base primitives, slide templates, and a builder. The adaptive slide type inference (`infer_slide_type`) is a clever design pattern that allows the same API to accept loosely-typed payloads. The library is production-ready, with provenance from a real consulting tool (AX Labs).

This is a Claude Code plugin that enables scheduling recurring and one-time tasks using native OS schedulers (launchd on macOS, crontab on Linux, Task Scheduler on Windows). Users describe tasks in natural language (e.g., 'every weekday at 9am review yesterday's code'), and the plugin converts that to cron expressions, registers the task with the OS scheduler, and executes `claude -p "prompt"` at the scheduled time. It supports autonomous execution with `--dangerously-skip-permissions`, git worktree isolation for tasks that modify code (creates a branch, runs Claude, commits and pushes changes), and provides commands to list, remove, run, and view logs of scheduled tasks. The architecture is modular: platform-specific scheduler implementations inherit from a base class, cron parsing and humanization are separate utilities, and execution history is stored as JSONL files. The codebase demonstrates strong security awareness with shell escaping, input validation via Zod schemas, and careful handling of user-provided values in generated shell scripts.

This is the official curated marketplace and development toolkit for Claude Code plugins, maintained by Anthropic. It contains both first-party plugins (e.g., claude-security, code-modernization, hookify, skill-creator, security-guidance) and third-party channel integrations (Discord, iMessage, Telegram, GitHub, Linear, etc.). The repository serves dual roles: as a plugin registry with standardized packaging (SKILL.md, agent definitions, hooks, commands, MCP servers) and as a meta-development kit providing tools for authoring and validating new plugins. The codebase is predominantly instructional content for Claude Code (markdown workflows, agent system prompts, skill references) orchestrated through hooks, workflows, and commands. While many plugins contain only reference documentation and no executable code, security-critical plugins like claude-security and security-guidance include sophisticated Python/JavaScript logic for vulnerability scanning, patch generation, session state management, and git diff analysis. The CI pipeline enforces licensing (Apache 2.0), validates plugin structure, checks MCP URL liveness, and manages SHA-pinned external plugin versions. The project is actively maintained but exhibits technical drift from duplicated access-control logic across channel servers, hardcoded model references, and reliance on Claude Code CLI internals that may change between versions.

This repo is a structured AI-assisted long-form article writing system, primarily delivered as a Claude Code plugin and a Tauri desktop app. It orchestrates a 14+ stage workflow (topic clarification, research, drafting, humanization, fact-checking, export) using specialized subagents and a central workflow contract (`collab_v2.json`). The system is model-agnostic, supporting Anthropic-compatible APIs including Chinese providers. It includes extensive tooling for evidence management, style modeling, blind evaluation, and publication metrics. While the core functionality is robust and well-tested, the codebase suffers from triple directory mirroring (`.claude/`, `claude-runtime/`, `plugins/writing-agent/`) requiring manual sync, hardcoded Windows paths in the desktop app, and a partially unverified style library. The architecture cleanly separates agent prompts (Markdown), runtime scripts (Python/Node), and a Tauri frontend, making the workflow itself reusable as a pattern for multi-stage AI agent orchestration.

This repository is a Claude Code plugin and design system library for generating zero-dependency HTML presentations. It provides a structured workflow (SKILL.md) for an AI agent to create single-file slide decks with inline CSS/JS, featuring 34+ curated design templates (bold-template-pack) with detailed color palettes, typography scales, component definitions, and CJK internationalization guidance. The core runtime component is a reusable `<deck-stage>` web component that handles slide navigation, keyboard controls, auto-scaling, print support, and speaker notes. Supporting scripts enable Vercel deployment, PDF export via Playwright, and PowerPoint-to-JSON extraction. The repository is primarily a design specification library consumed by an AI coding agent, not a standalone application. It exhibits a hybrid nature: the templates are extensive design documentation (not executable code), while the plugin infrastructure and web component are functional code. The design philosophy emphasizes anti-generic aesthetics, fixed 16:9 stage scaling, and progressive disclosure of supporting files. Notable duplication exists between root and plugin paths, and all templates are marked alpha.

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.

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.

tsumiki is a Claude Code plugin and skill library that operationalizes AI Test-Driven Development (AITDD). It exposes slash commands (`/dev-impl`, `/dev-debug`, `/ipa-security-check`, `/orchestrate`) and Markdown-based skills that guide an AI coding agent through a Red-Green-Refactor-Validation cycle. The repository is not a standalone runtime; it is a development methodology toolkit whose primary artifacts are command definitions, skill instructions, and workflow orchestration logic consumed by Claude Code.

This repository is a Claude Code skill bundle for Generative Engine Optimization (GEO) and SEO auditing, distributed as an installable plugin. The core deliverable is a composite GEO Score (0-100) computed from six weighted categories: AI citability, brand authority, content E-E-A-T, technical health, structured data, and platform optimization. Users invoke slash commands such as /geo audit, /geo quick, /geo citability, /geo llmstxt, and /geo report, which orchestrate a set of skill definitions, agent prompts, and Python helper scripts to crawl external websites, analyze AI crawler accessibility, extract JSON-LD, generate llms.txt files, score content passages, and produce client-ready reports and proposals. It also includes a small Flask + HTMX CRM webapp for managing prospects and a white-label configuration system for agencies. The architecture is primarily a composition of markdown-based skills and agents with Python scripts as deterministic helpers. The main entry points are geo/SKILL.md (orchestrator), the scripts under scripts/, and the webapp at scripts/webapp/app.py. The system behaves as a productized agency service: it runs audits against arbitrary client domains, produces quantitative scores, generates branded PDF reports, pricing proposals, and monthly delta comparisons. Some research-oriented artifacts exist - cited market studies, scoring methodology documentation, and heuristic rubrics - but the dominant character is an application toolkit for practitioners rather than a data pipeline. Strengths include a clear JSON-to-stdout contract between scripts and skills, deterministic scoring modules such as citability_scorer.py and llmstxt_generator.py, reusable JSON-LD schema templates, and a sensible separation between deterministic checks and LLM-judged scoring. Weaknesses include documentation drift (inconsistent skill counts and command references), duplicated scoring rubrics in agent vs skill versions, a legacy ReportLab PDF pipeline documented alongside the newer pandoc/Chrome approach, and only narrow test coverage focused on fetch_page.py.

This repository is an open-source terminal-based AI coding assistant built in Rust, clean-room reimplementing Anthropic's Claude Code. It provides an interactive TUI (ratatui) for multi-provider LLM conversation (Anthropic, OpenAI, Google, and 30+ OpenAI-compatible) with a rich tool ecosystem for file editing, bash execution, MCP integration, code analysis, web fetching, and agent orchestration. The architecture is modular: a provider abstraction layer (`LlmProvider` trait), plugin system, slash commands, session management, and an Agent Client Protocol (ACP) for external IDE integration. The codebase is organized into 12+ workspace crates with clear separation of concerns, but many modules are still in active refactoring (issue #232) with stubs, TODOs, and incomplete feature gates (36 experimental features). The permission system, tool budget enforcement, and streaming decoders demonstrate strong engineering, while dual feature flag systems and global mutable state introduce maintenance risk. Overall, it is a feature-rich, well-architected application with some rough edges from ongoing migration.