thehardwarestore.ai

SurveyX is an academic survey automation system that leverages Large Language Models (LLMs) to generate domain-specific academic papers from user-provided references. The system implements a modular pipeline that processes markdown-formatted reference documents through stages of preprocessing, outline generation, content drafting, post-refinement (citation correction, figure/table insertion), and LaTeX/PDF output generation. Designed for offline use in its open-source version, it accepts survey titles, keywords, and local reference paths to produce structured surveys with watermarked PDF outputs. The architecture emphasizes separation of concerns with distinct modules for LLM interaction, content refinement, and document generation, supported by monitoring utilities for tracking token usage and pipeline timing.

This repository is a collection of configuration templates for Codex CLI, an AI coding assistant. It provides a structured set of configuration files (config.toml, AGENTS.md, sub-agent definitions, and skill files) to enable multi-agent parallel workflows, system-level contracts via developer_instructions, and a well-crafted terminal dialog style. The templates are designed to be copied into the user's ~/.codex directory to configure Codex CLI for efficient, visually structured AI interactions. The repository is actively maintained with frequent updates aligning with Codex CLI releases, and demonstrates high craftsmanship in prompt engineering and configuration design. It is not a traditional software application but a configuration-as-code repository that optimizes an existing tool.

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.

CtxPort is a browser extension and companion documentation website that lets users copy AI conversations (from ChatGPT, Claude, Gemini, DeepSeek, Grok, Doubao, GitHub) as structured Markdown Context Bundles. It solves 'context rot' by enabling portable, lossless migration of conversations between AI tools without uploading data to third parties. The architecture is a modern monorepo using pnpm workspaces and Turborepo, with separate packages for schema validation (Zod), markdown serialization, plugin-based extraction, and shared UI components. The browser extension (Manifest V3, WXT, React 19, Tailwind CSS 4) injects copy buttons and sidebar list icons into supported platforms, while the documentation website (Next.js + Nextra) provides multilingual (en/zh) user guides and feature descriptions. All processing is client-side; no data is uploaded. The codebase demonstrates strong engineering practices including a plugin system for extensibility, a strategy pattern for content flatteners, clean separation of concerns, and comprehensive CI/CD pipelines. Some fragility exists in DOM selectors and platform APIs, but the architecture is well-structured for adaptation.

This repository implements a GitHub Action (`actions/ai-inference`) that runs AI model inference inside GitHub Actions workflows by shelling out to the GitHub Copilot CLI. The action accepts a user prompt (inline or from a file), an optional system prompt, a model identifier, and various configuration options. It builds a combined prompt string, spawns the Copilot CLI with `-p`, `-s`, and `--no-ask-user` flags, captures the model's text response, and exposes it via `response` and `response-file` outputs. The architecture is a single Node.js action (bundled into `dist/index.js`) with modular TypeScript source files: `main.ts` orchestrates input parsing and provider dispatch, `copilot.ts` handles CLI invocation and error handling, `prompt.ts` provides structured `.prompt.yml` file parsing with template variable substitution, and `helpers.ts` contains utility functions. The action is tightly coupled to the Copilot CLI, which must be pre-installed and authenticated on the runner. It supports only the `copilot` provider. The codebase is well-structured, includes unit tests, and follows modern TypeScript practices.

Promptimize is a prompt engineering evaluation and testing toolkit implemented as a Python library with CLI interface. It enables users to define prompt cases (test cases for LLM prompts) as code, associate evaluation functions that score responses on a 0-1 scale, execute test suites across different models and configurations, and generate performance reports. The architecture centers around BasePromptCase and its derivatives (PromptCase, TemplatedPromptCase, LangchainPromptCase) which encapsulate prompt logic and evaluation, Suite classes that manage collections of prompt cases and handle execution/reporting, and utility modules for templating, caching, and result serialization. The toolkit minimizes redundant API calls by caching prompt executions and only re-running when prompts change, supports human review for edge cases, and integrates with Langchain/OpenAI for LLM interactions.

This repository is a comprehensive plugin marketplace and reference implementation for legal practice automation using Anthropic's Claude AI. It contains 12 first-party plugins (commercial, corporate, employment, privacy, product, regulatory, AI governance, IP, litigation, legal clinic, law student, and a builder hub) plus one vendor plugin from Thomson Reuters. Each plugin provides a set of 'skills' (prompt-engineered workflows) invoked via slash commands, a cold-start interview to configure the AI to a specific legal professional's role and preferences, and optional scheduled agents. The repo also includes five managed-agent cookbooks demonstrating multi-agent orchestration with tool isolation (read-only subagents, write leaf, orchestrator with no write access). While the vast majority of content is markdown prompt files, the repository also contains reusable Python and shell scripts for deployment, validation, and linting of agent configurations. The system is designed to be deployed on Claude Code or Claude Cowork, with MCP connectors for legal research tools, document management, and other integrations. It emphasizes citation provenance, injection defense, and consequential-action gates for non-lawyer users.

langchaingo is a Go port of the LangChain framework, providing a modular, composable library for building LLM-powered applications. In production, it serves as an abstraction layer over dozens of LLM providers (OpenAI, Anthropic, Google AI, AWS Bedrock, Ollama, HuggingFace, etc.), vector stores (Chroma, Pinecone, Weaviate, pgvector, Redis, Qdrant, and many more), and supporting components such as chains, agents, memory, tools, document loaders, and prompt templates. The architecture is a monorepo library: users import packages and compose interfaces (`Model`, `Chain`, `VectorStore`, `Agent`, `Memory`) to orchestrate LLM workflows. Key entry points are provider constructors (e.g., `openai.New()`) and composition functions (e.g., `chains.NewLLMChain()`, `agents.NewExecutor()`). The library relies on many external SDKs and databases, creating a large dependency surface. It includes a custom HTTP record/replay testing infrastructure (`httprr`) for deterministic testing of API calls. The codebase is actively maintained with recent commits and a large community, but carries medium technical drift due to some outdated dependencies and deprecated API patterns.

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 is a collection of 12 lessons on effective AI-assisted software development, derived from real-world experience with tools like Cursor, Windsurf, Cline, and Claude. It is not a software application or data research project—it is pure documentation. The lessons cover project structure, planning, problem decomposition, test writing, commit discipline, and prompt engineering. The content is clear, concise, and immediately applicable. No code or data pipelines are present; the value lies in the reusable practices and mental models it teaches.

unslop is a CLI tool that empirically detects repetitive defaults in AI-generated outputs (text or visual) and produces a reusable instruction file (skill.md) to eliminate those patterns. It works by generating a set of prompts for a given domain, running them through Claude Code to produce samples, analyzing the samples for repeated patterns (phrases, structures, visual defaults), and writing a focused 'unslop profile' that tells the model what to avoid. The tool supports both text domains (blog writing, emails, tutorials) and visual domains (landing pages, UI mockups) with optional screenshot rendering via Playwright. The architecture is a single Python script (unslop.py) that orchestrates a multi-step pipeline: prompt generation, sample generation via parallel Claude Code calls, screenshot rendering (visual only), pattern analysis, skill file generation, and a before/after comparison. It uses asyncio for concurrency, a custom terminal UI with live spinners and progress bars, and a robust subprocess wrapper for the Claude CLI that handles streaming JSON output, timeouts, retries, and permission denials. Key entry points are the CLI arguments (--domain, --type, --count, --concurrency, etc.) and the main async run() function. External dependencies are the Claude Code CLI (claude command), Python 3.10+, and optionally Playwright for visual domains. The output is a directory (unslop-output/) containing the skill file, analysis, prompts, samples, screenshots, and before/after comparison. The code demonstrates solid async patterns, clean separation of concerns within a single file, and a well-designed terminal UI abstraction. It is not a library but a self-contained tool that could be adapted for other AI model backends by replacing the claude() function.

Eko is a TypeScript framework for building production-ready AI agents that can automate workflows across browser, Node.js, and web extension environments. The core orchestration engine (Eko class) takes a natural language task, uses an LLM to generate a multi-agent workflow plan encoded as XML, then executes it with parallel/serial agent execution, replanning, and human-in-the-loop support. The system provides a clean abstraction over LLM providers (OpenAI, Anthropic, etc.) with retry and fallback, a ReAct tool-calling loop, and built-in browser automation agents that operate via screenshots or DOM labels. It also includes MCP client implementations (SSE, HTTP, stdio) for integrating external tools, and a chat agent for conversational interactions with tool delegation. The architecture is modular with separate npm packages: @eko-ai/eko-core (core engine), @eko-ai/eko-nodejs (Playwright-based browser agent), @eko-ai/eko-extension (Chrome extension agent), and @eko-ai/eko-web (web environment agent). The repository includes working examples (Chrome extension with side panel, Node.js automation using Playwright, and a React web app). The framework is designed for developers who want to automate complex, multi-step tasks using language models, with a focus on reliability, human oversight, and extensibility via custom agents and tools.

This repository implements and evaluates Function Vectors (FVs) for steering large language models (LLMs) without fine-tuning. The core workflow involves computing task-conditioned mean head activations from in-context learning examples, identifying causally influential attention heads via indirect effect, summing their outputs to form the FV, and applying it during inference to elicit target behaviors (e.g., translation, inflection). The system provides a modular Python library with utilities for model loading, prompt construction, activation extraction, intervention, and evaluation, accompanied by a demo notebook and evaluation scripts for running experiments on various linguistic datasets. While the codebase demonstrates clean separation of concerns and contains reusable components for model intervention and prompt handling, it shows signs of technical drift due to dependency rigidity and architecture-specific hooks, and appears to have stagnated in maintenance with no recent updates.

This repository is a plugin for Claude Code, providing a set of 10 structured 'skills' based on the book 'The Minimalist Entrepreneur' by Sahil Lavingia. Each skill is a Markdown file with YAML frontmatter that defines a command name, description, and a detailed system prompt. When installed, Claude Code can invoke these skills via slash commands (e.g., `/find-community`, `/mvp`) to guide users through business advice frameworks. The repo contains no executable code, tests, or CI/CD pipelines—it is purely a collection of well-organized prompt templates. The architecture is trivial: a plugin manifest and a directory of skill files. While the content is thoughtfully crafted and follows a consistent structure, there is no software craftsmanship to evaluate; the repo's value lies in its instructional design rather than code quality. It is actively maintained by the book's author and serves its niche purpose effectively, but it offers no reusable software components for other projects.

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.