thehardwarestore.ai

This is a comprehensive educational course repository ('Generative AI for Beginners') containing 21 structured lessons covering the full spectrum of generative AI application development. While classified as an application repository due to its extensive runnable code examples across Python, JavaScript, TypeScript, and .NET, its primary purpose is pedagogical. The repository teaches practical patterns for building GenAI applications including: prompt engineering, chat applications, RAG/vector search, image generation, function calling, AI agents, fine-tuning, LLMOps, and responsible AI practices. Each lesson provides assignments and solutions for multiple LLM providers (Azure OpenAI, OpenAI, GitHub Models). The codebase demonstrates modern GenAI application patterns with a strong emphasis on multi-language implementation parity and accessibility through 40+ language translations. The shared/python utilities provide reusable helpers for API interactions, environment management, and input validation that could be extracted for production use.

This is a full-stack cultivation world simulator game (xianxia RPG) with a Python backend (FastAPI + asyncio) and a Vue 3 + TypeScript + PixiJS frontend, supported by an optional Electron desktop shell for Epic Games Store distribution. The simulation engine runs a month-by-month tick system orchestrating ~29 phases (lifecycle, actions, social, war, world events, etc.) producing emergent narratives driven by LLM calls (OpenAI/Anthropic compatible) for character decisions, story generation, world lore rewriting, and roleplay interactions. The codebase is heavily data-driven with static game configurations (sects, techniques, items, regions) loaded from CSV files and multi-language localization via gettext PO files. It exposes a public REST API (query/command) and WebSocket for real-time state updates, supports save/load with JSON snapshots and SQLite event storage, and includes comprehensive test coverage (pytest, vitest, Playwright) and CI/CD workflows. While the architecture shows strong engineering patterns (effect system, action registry, single-choice decision framework, phased simulation pipeline), it carries risks from tight coupling of global singleton registries, LLM dependency, and use of `eval` in effect conditions.

This repository provides a Claude Skill for detecting and removing 'AI slop' from Japanese prose. It consists of a set of guidelines (SKILL.md) and reference files that enumerate problematic phrases, structural patterns, and examples of AI-generated text versus human-revised versions. The skill focuses on restoring human agency, stance, specificity, rhythm, and reduction in LLM-generated Japanese text. It is designed to be used during drafting, editing, or review stages to improve the authenticity of AI-assisted writing.

This is a knowledge/content repository, not a running software system: a curated collection of 11 'Agent Skills' packages compliant with the Agent Skills specification (agentskills.io), designed to be loaded on-demand by AI coding agents (Claude Code, Codex, Cursor, etc.) and other LLM runtimes. Each package is a self-contained directory with a SKILL.md entry point (YAML frontmatter with name/description plus routing instructions), plus references/, assets/, scripts/, and optional agents/ metadata. The skills cover research-analysis (deep-architecture-research with a confirmation-gate and evidence-ledger protocol; neural-mechanism-research; review-ai-conversations with reverse-engineered adapters for Claude Code, Codex, opencode, Grok Build, and Cursor conversation stores; understanding-first-report), software engineering (vibe-coding with scenario/domain/phases sub-references), team collaboration (meeting-coach-leader/worker), agent development (agent-builder with actual Python starter code; skill-judge with a 120-point rubric), and content publishing (media-writer for 7 platforms). There is no application entry point, server, or pipeline; the 'product' is the instructional content and routing logic itself. Although classified as application due to its standalone Python tools and operational guidance (rather than data pipeline), the repo is fundamentally a hybrid: most value comes from the rigor of its written protocols and evaluation rubrics, not executable code. The only real code lives in agent-builder (~4 self-contained Python files: minimal-agent.py, subagent-pattern.py, tool-templates.py, init_agent.py) which implement a clean, security-conscious agent loop. The most impressive craft is the data-engineering-style documentation in review-ai-conversations, which precisely specifies the storage schemas (SQLite tables, JSONL shapes, lineage/parent-child rules) of five proprietary agent tools, each fact tagged with provenance evidence ([CODE]/[DOC]/[ISSUE]) and version-pinned research dates. The skill-judge rubric and deep-architecture evidence protocol likewise demonstrate non-trivial expertise: hard gates, severity levels, evidence-vs-inference discipline, and explicit anti-patterns. The repo is actively maintained (last commit 2026-09-16, in-repo evidence research dated 2026-08-23, plus a documented skill-rename migration path in the READMEs, which exist in English, Chinese, and Japanese). Technical drift is low: the pinned model (claude-sonnet-4-20250514), SDK usage, and cited external tools (Codex 0.148.0, Cursor 2026.08) are current. No test suite exists, but that is the wrong bar for a documentation-oriented collection; the applicable standards are structural validity, evidence quality, and progressive-disclosure design, which are handled well. Weaknesses: media-writer's platform guides are somewhat generic social-media advice, some philosophical prose is repetitive, and the Python examples lack a requirements.txt/pinned dependency file.

QueryChat is a dual R/Python open-source library that turns tabular data into a natural-language chat interface: users ask questions in plain English, an LLM generates SQL via tool calls, and the SQL executes against an in-memory DuckDB engine, a SQLAlchemy-managed database, an Ibis backend, a Polars lazy frame, or a pins board. A defining safety property is that raw data is never sent to the LLM — only schema introspection (column names, types, ranges, categorical values) and query results flow through the model. The package ships with five LLM-visible tools (get_schema, query, update_dashboard, reset_dashboard, visualize) and a hardened DuckDB mode that blocks external filesystem access and extensions, making it a well-considered solution to the inherently risky problem of letting models write SQL against user data.

This repository is a Claude Code/Pi skills framework for academic research and writing. It packages markdown skills, agent definitions, and Python tooling that together support the full research pipeline: topic discovery, deep research, paper writing, review, citation verification, and meta-analysis. The dominant character is application/tooling: it has CLI entry points, a Pi wrapper, dozens of lint/check scripts, and a large test suite. It is not a data pipeline, though it includes network-backed citation lookup scripts and research-oriented data-integrity checks.

OpenAgents Control (OAC) is a framework for managing, testing, and orchestrating AI coding agents. It provides a CLI tool (`oac`) to install, update, and manage agents, context files, and skills from a registry. The system includes a plugin architecture for OpenCode and a compatibility layer that converts agent definitions between OAC, Claude Code, Cursor, and Windsurf formats. A comprehensive evaluation framework tests agent behavior against critical rules (approval gates, context loading, stop-on-failure, delegation, tool usage) using YAML-defined test suites and timeline-based analysis. The repository is primarily a software development toolchain for AI-assisted coding workflows, with strong emphasis on deterministic safety rules and multi-agent coordination.

This repository is a comprehensively governed, production-grade library of 115+ prompt templates, meta-prompt generators, workshop guides, and structured routines for AI-assisted product management. It is not a deployed software application but rather a content methodology repository with application-like engineering discipline: standalone prompt contracts, coupling levels, CI-validated metadata, deterministic catalog generation, and an explicit coupling remediation plan. The library covers the full product management lifecycle—discovery, strategy, requirements, competitive intelligence, end-of-life, storytelling, and team facilitation—using three defined interaction modes (facilitation, co-construction, autonomous investigation). Notable sub-collections include an eight-discipline market intelligence framework (OSINT, FININT, GEOINT, etc.) with an all-source fusion prompt, a complete product sunset (EOL) workflow, and a TAM-SAM-SOM market sizing Langflow pipeline. The repo exhibits hybrid character: while primarily a content asset, it includes reusable Python scripts for validation and catalog generation, a GitHub Actions CI pipeline, and follows software engineering best practices such as versioning, changelogs, and architectural decision records.

This repository is a curated resource hub (awesome list) for Claude Code skills, targeting Chinese-speaking developers. It contains 20 original SKILL.md files that can be directly installed into Claude Code, plus a curated directory of 441+ third-party skills organized by categories such as development efficiency, content creation, platform operations, and more. The repo includes a static website (docs/index.html) that mirrors the README, automated Python/Node.js scripts for synchronization, and rigorous CI/CD pipelines with pinned dependencies and comprehensive tests. It is not a running application but a content curation project with high-quality infrastructure for maintaining consistency between the README and the website, including atomic file writes and strict anchor validation. The original skills are well-structured and cover practical scenarios like code review, documentation generation, API testing, and refactoring, all in Chinese.

EvoMap Evolver is a self-evolving AI agent engine built as a Node.js >=22.12 CLI daemon. It runs a genome-evolution loop: scans session memory/logs, extracts signals, selects 'Genes' (prompt/strategy patches) and 'Capsules' (validated skill bundles) from a local JSON/JSONL asset store, generates GEP-framed prompts for coding agents (Claude Code, Codex, Cursor, Gemini CLI, opencode, Kiro), executes those sessions, and records outcomes in a memory graph to adapt future selections. The system solidifies successful patterns into new reusable assets, auto-distills failure patterns and SKILL.md files into Genes/Capsules, and can open PRs or run validation sandboxes against candidate changes. It also ships an LLM proxy (Anthropic/OpenAI/Gemini/Vertex/Ollama routes with trace encryption and token-savings attribution), an ATP (Agent Transaction Protocol) marketplace for buying/completing agent tasks with auto-buyer and auto-deliver, a validation daemon for decentralized task verification, a local Web UI dashboard, and an experiment runner for A/B comparing evolution strategies. Hub synchronization (SSE event delivery, mailbox sync, OAuth device login) connects nodes to the evomap.ai network, but the system is designed to degrade gracefully into fully offline solo mode.

This repository is a curated library of over 230 specialized AI agent definitions, each with a detailed persona, mission, rules, deliverables, and workflow. It serves as a multi-agent orchestration framework (NEXUS) that coordinates agents through phases with quality gates and handoffs. The agents are designed to be installed into various AI coding tools (Claude Code, Cursor, Copilot, etc.) via a modular installer and conversion pipeline. The repository also includes strategy documents, runbooks, and coordination templates for managing multi-agent projects. While primarily a collection of prompt definitions, it is supported by a robust set of scripts for validation, installation, and consistency checking, making it a practical tool for deploying AI agents in real-world workflows.

Promptify is a Python library for performing NLP tasks using large language models (LLMs) with structured, type-safe outputs. It provides a scikit-learn-like interface where users instantiate task classes (e.g., NER, Classify, QA, Summarize) and call them with plain text. The library uses LiteLLM as a universal backend to support 100+ providers (OpenAI, Anthropic, Ollama, etc.), Pydantic v2 for output schemas, Jinja2 for prompt templates, and tenacity for retries. Architecture follows a clean separation: Task classes (promptify/tasks) build prompts via PromptBuilder, send them via LLMEngine (which wraps LiteLLM), and parse responses via a safe Parser that never uses eval(). The package also includes a built-in evaluation framework (promptify/eval) with metrics for precision, recall, F1, accuracy, exact match, and ROUGE, plus dataset loading utilities. The code is well-structured, typed, and includes comprehensive tests. The primary artifact is the "promptify" Python package, installable via pip. The repository is not a data research project; it is a software library for developers.

The academic-skills repository is a collection of prompt engineering assets designed to assist with academic research workflows when used with large language models like ChatGPT. It provides eight distinct skills, each encapsulated in a self-contained directory containing a skill description (SKILL.md), platform-specific metadata (agents/openai.yaml), and optional reference templates or scripts. The skills cover tasks such as reading and noting papers, writing literature surveys, monitoring arXiv for new publications, analyzing reviewer comments, summarizing experiment logs, extracting benchmark information, identifying research gaps, and generating weekly lab updates. The repository emphasizes reliability and reproducibility by constraining LLM outputs to avoid hallucination, providing clear input processing rules, and offering structured templates for consistent results. One skill (paper-feishu-digest) includes a deterministic Python script for fetching and filtering arXiv papers, demonstrating a hybrid approach that combines LLM assistance with traditional data processing. Additional tools for validating the repository structure and packaging skills for distribution are included, all written using only the Python standard library to minimize dependencies. The codebase exhibits strong modularity, with each skill following a uniform structure that facilitates maintenance and extension. The arxiv_digest.py script stands out as a reusable component for arXiv data processing, featuring robust error handling, keyword-based ranking, and conservative inference of paper contributions and limitations from abstracts. Overall, the repository represents a well-crafted toolkit for enhancing academic productivity through LLM augmentation, balancing prompt engineering with selective use of deterministic scripts where appropriate.

This repository is the official community library for GitHub Copilot customizations, including agents, skills, instructions, plugins, canvas extensions, git hooks, and a cookbook of SDK recipes in multiple languages. It also hosts a production-quality React website (Astro + Primer Brand) that catalogs all resources with search, filters, and detail pages. The codebase is primarily a collection of markdown files, JavaScript/TypeScript modules, and Python scripts, organized into well-defined directories with validation tooling in `eng/`. While the website and some extensions (draw, pr-artifact-explorer, arcade games) demonstrate solid front-end architecture, the majority of content is declarative configuration and documentation. The repository is actively maintained with frequent commits and CI workflows, though the sheer volume of community contributions introduces inconsistency risks in skill structure and dependency pinning.

Prompt Optimizer is a multi-platform AI prompt optimization tool that helps users craft better prompts for large language models (LLMs) and image generation models. The system supports web (Vue 3 + Naive UI), desktop (Electron), Chrome extension, MCP server, and Docker deployment via a pnpm monorepo. Core workflows include system/user prompt optimization, evaluation with structured compare (pair-judge, synthesis), image generation (text2image, image2image, multi-image), variable extraction/value generation, a template system with 40+ built-in bilingual (zh/en) templates, and smart favorites with resource-aware asset management. The architecture cleanly separates framework-agnostic core services (LLM adapters, evaluation, storage, template processing) from UI composables and Electron proxies, using adapter, registry, and factory patterns extensively. A notable strength is the comprehensive test infrastructure spanning unit (Vitest), integration (real LLM API helpers gated by environment flags), and E2E (Playwright with VCR record/replay). Weaknesses include significant template duplication (bilingual files maintained separately), IPC fragility between Electron main/renderer, provider adapter maintenance overhead (16+ text adapters, 6+ image adapters), and some dead/deprecated code paths carrying legacy migration layers.

oh-my-antigravity (OmA) is an extension for Gemini CLI that adds a structured, role-driven multi-agent workflow layer on top of the base CLI. It transforms a single-session AI assistant into an orchestrated engineering pipeline with roles such as architect, planner, executor, reviewer, and verifier. The extension provides over 40 slash commands, 11 retained deep-work skills, 13 sub-agent definitions, and two shipped hooks (silent BeforeModel model router and AfterAgent learn-signal filter). The architecture is entirely extension-native, relying on Gemini CLI's extension manifest (`gemini-extension.json`), command definitions in TOML files, agent prompts in Markdown, and hook scripts in JavaScript. The primary data flow is user input → `/oma:*` command → staged pipeline (intent → workspace → team-assemble → team-plan → team-prd → team-exec → team-verify → team-fix → loop) with persistent state in `.omg/state/`. The codebase demonstrates strong engineering discipline with version consistency checks, skill metadata validation, atomic file writes, environment-variable-driven runtime controls, and thorough documentation. It is not a data research project; it is a workflow automation and context-engineering pack for an AI terminal agent.

This repository contains the GitHub Copilot Chat extension for Visual Studio Code. It provides an AI-powered coding assistant with multiple interaction modes: inline code completions (ghost text), chat conversations, inline edits, next-edit suggestions, and agent-based tool orchestration. The extension supports multiple AI model providers (OpenAI, Anthropic, Google Gemini, xAI, and bring-your-own-key endpoints) and includes a sophisticated prompt engineering system using JSX-based prompt elements. It integrates deeply with VS Code through dozens of proposed APIs, and features a layered architecture (common/node/vscode) with dependency injection, telemetry, and a simulation test framework. While the README states the project has moved to the main VS Code repository, the codebase shows active development with recent commits and extensive feature work.

POML (Prompt Orchestration Markup Language) is a developer toolchain for structured, reusable LLM prompt engineering. It provides an HTML-like markup language with semantic components, CSS-like styling, templating (variables, loops, conditionals), and multimodal data integration (PDFs, images, tables). The repository contains a core TypeScript/React SDK, a Python wrapper with OpenAI/LangChain/MLflow integrations, a VS Code extension (LSP, live preview, test command), and a Chrome browser extension for content extraction. It is packaged as CLI tools and libraries on npm and PyPI. Designed for building maintainable prompts in LLM applications, it also includes research artifacts (arXiv papers) and a tracing system for debugging prompt execution.

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.