planning-with-files is a persistent, file-based task-planning system for AI coding agents. It maintains task_plan.md, findings.md, and progress.md on disk and wires into agent lifecycle hooks (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, PreCompact, Stop) across Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, Pi, Hermes, and a dozen other assistants, re-injecting plan context into the model's context window on every turn. Plans survive context loss, /clear, compaction, and crashes; a session-catchup mechanism recovers prior transcripts. A v3 gated mode can block the agent from stopping until plan phases complete, backed by an append-only JSONL run ledger, stall detection, and SHA-256 plan attestation that makes hooks refuse to inject tampered content. Architecturally it is a distribution hub rather than a single application: a canonical skill under skills/planning-with-files is mirrored byte-identical into 15+ IDE-specific directories, with native TypeScript plugins (OpenCode, Pi, DSH), a Python plugin (Hermes), and shell/PowerShell hook dispatchers. Plan resolution is a fail-closed chain (PLAN_ID env → .active_plan pointer → newest plan dir → legacy root) guarded by slug validation, containment checks, symlink/junction rejection, and strict PWF_PLAN_ROOT pinning. The engineering is unusually rigorous for an agent-skill repo: 400+ pytest tests, byte-parity tests between shell/PowerShell/Python/TypeScript twins, a PATH-stub BSD userland simulation to catch GNU-only flags that silently fail on macOS, and heavy Windows PowerShell 5.1 / Git Bash portability hardening. Non-obvious patterns include KV-cache-stable injection output (no timestamps or free text in summaries, wall-clock normalization to T00:00:00Z) and an mtime-keyed attestation cache for performance. The repository is a developer tool, not a data/research project; although it ships benchmark and eval documentation (assertion pass rates, recovery-turn comparisons), those are verification evidence for the skill, not analysis artifacts. It is actively maintained at v3.24.0 with recent commits, 4 open issues, and 100+ releases; technical drift is low, with the main maintainability risk being deliberate duplication across 20+ canonical mirrors, mitigated by sync-ide-folders.py and parity tests but still a possible source of silent drift.
This repository provides a two-skill workflow system for academic paper creation designed to work with Claude Code. The 'academic-paper-strategist' skill handles research planning through platform analysis, literature search, gap identification, and outline optimization with quality gates. The 'academic-paper-composer' skill executes systematic writing from outlines with chapter-level quality checks and final evaluation. The system emphasizes quality control through structured rubrics and iterative validation, transforming research ideas into submission-ready manuscripts with comprehensive quality reports. While primarily documentation-heavy, it contains several self-contained, reusable evaluation systems that demonstrate sophisticated assessment frameworks.
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.
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.
This repository is a comprehensive knowledge base and reference implementation for Claude Code best practices, curated by Shayan Rais. It is not a standalone application but rather a living documentation and configuration library that demonstrates how to effectively use Claude Code CLI through agents, skills, commands, hooks, and workflows. The core architecture follows a Command → Agent → Skill orchestration pattern, with working examples such as a weather reporter system and a structured RPI (Research-Plan-Implement) development workflow. The repository includes reusable configuration patterns (YAML frontmatter schemas for agents and skills), a cross-platform Python hook script for lifecycle events, detailed changelogs that track drift against official Claude Code documentation, and extensive reference guides covering settings, environment variables, MCP servers, and startup flags. While primarily a documentation and reference project, it contains runnable Claude Code configurations that can be directly adopted or adapted by other projects.
This is a VS Code extension that provides a unified interface for discovering, installing, and managing MCP (Model Context Protocol) servers and AI agent skills. It integrates with multiple sources: the Official MCP Registry, skills.sh, GitHub repositories, and CloudMCP (a hosted alternative). The extension offers a chat participant (`@mcp`) for natural-language search and install, and a sidebar webview with search and management tabs. It supports 30+ AI coding agents including GitHub Copilot, Claude Code, and Codex CLI. The architecture consists of a TypeScript extension backend (using esbuild for bundling) and a React 19 + Vite + Tailwind CSS + shadcn/ui frontend, communicating via typed RPC messages. Telemetry is collected anonymously with standardized error classification. The codebase is well-structured with clear separation of concerns, CI/CD pipelines, and unit tests.
This repository is a collection of Claude Code skills and Python scripts that automate daily paper recommendation and note-taking for researchers. It fetches papers from HuggingFace Daily Papers, HuggingFace Trending, and arXiv API, scores them against user-defined keywords, enriches metadata (authors, affiliations, figures, method names), and generates a tiered daily recommendation markdown file (must-read, worth reading, skip). For must-read papers, it invokes a paper-reader skill that produces detailed structured notes with figures, formulas, tables, and concept wiki entries, all saved into an Obsidian vault. It also fetches GitHub Trending repositories and writes notes. The system includes a web viewer (FastAPI + vanilla JS) for browsing the vault content, with full-text search, wikilink resolution, and a Claude chat interface. The architecture is a three-step pipeline (fetch, review, notes) orchestrated by Claude Code skills, with Python scripts handling data fetching, scoring, enrichment, and file management. The codebase demonstrates solid engineering: async HTTP with fallback chains, robust HTML parsing, heuristic text extraction, and clean modular design. It is primarily an application (a set of tools) rather than a data research project, though it involves significant data processing.
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 is a monorepo of ~100 Claude Code skills — self-contained plugins that extend Claude Code's capabilities across personal automation, research, content creation, development tooling, and communication. Each skill is a directory with a SKILL.md (trigger definition), scripts/, references/, and assets/. The architecture is plugin-based: Claude Code matches user requests to skill triggers and executes the associated scripts. Skills range from simple CLI wrappers (e.g., YouTube transcript extraction) to multi-step pipelines (e.g., PII redaction with confide, release orchestration with cull-release, interview-driven skill design with skill-studio). The codebase demonstrates strong patterns: reversible PII redaction with typed placeholders, exact permutation statistics, weighted scoring with Pareto frontiers, and structured TDD loops. However, it also has technical debt: hardcoded user paths, some deprecated library usage, external API coupling, and a few design-spec-only skills. The dominant character is application (CLI tools and agent plugins), though several skills involve data analysis (health queries, experiment evaluation, evidence grading).
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.