Skip to content
Back to search

cc-polymath-marketplace

MarketplaceWorks with Claude CodeGitHub

Official marketplace for cc-polymath: efficient skill management with progressive discovery across 33+ domains

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/rand/cc-polymath with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/rand/cc-polymath'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/rand--cc-polymath/badge.svg)](/listings/rand--cc-polymath)

HTML

<a href="/listings/rand--cc-polymath"><img src="/api/listings/rand--cc-polymath/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Installation

**As Claude Code Plugin (Recommended)**:

/plugin install https://github.com/rand/cc-polymath

That's it! All 410+ skills and the `/skills` command are immediately available.

**For local development or testing**:

/plugin install /Users/rand/src/cc-polymath

Auto-Discovery (How It Works)

Just start working. Claude Code automatically activates relevant gateway skills based on your task keywords.

**Example**: Mention "REST API with PostgreSQL" → `discover-api` and `discover-database` gateways activate automatically.

Manual Loading

When you need to browse or plan:

# Browse skills catalog
cat skills/README.md

# View a category
cat skills/api/INDEX.md          # All API skills
cat skills/database/INDEX.md     # All database skills

# Load a gateway
cat skills/discover-ml/SKILL.md  # ML gateway with quick reference

# Load specific skills
cat skills/api/rest-api-design.md
cat skills/database/postgres-query-optimization.md

Composing Workflows

Skills are designed to combine for complex workflows:

**Full-stack web app**:

cat skills/api/rest-api-design.md
cat skills/frontend/nextjs-app-router.md
cat skills/database/postgres-schema-design.md
cat skills/caching/redis-caching-patterns.md
cat skills/cicd/github-actions-workflows.md

**ML deployment with DSPy**:

cat skills/ml/dspy-setup.md
cat skills/ml/dspy-modules.md
cat skills/modal/modal-gpu-workloads.md
cat skills/modal/modal-web-endpoints.md
cat skills/observability/structured-logging.md

**Multi-layer caching strategy**:

cat skills/caching/caching-fundamentals.md
cat skills/caching/service-worker-caching.md    # Browser
cat skills/caching/http-caching.md              # HTTP layer
cat skills/caching/cdn-edge-caching.md          # CDN edge
cat skills/caching/redis-caching-patterns.md    # Application
cat skills/caching/cache-invalidation-strategies.md

**iOS app with streaming backend**:

cat skills/mobile/swiftui-architecture.md
cat skills/mobile/swift-concurrency.md
cat skills/mobile/swiftdata-persistence.md
cat skills/mobile/ios-networking.md
cat skills/database/redpanda-streaming.md

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 16 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "cc-polymath-marketplace",
  3. "description": "Official marketplace for cc-polymath: efficient skill management with progressive discovery across 33+ domains",
  4. "owner": {
  5. "name": "rand",
  6. "url": "https://github.com/rand/cc-polymath"
  7. },
  8. "plugins": [
  9. {
  10. "name": "cc-polymath",
  11. "source": "./",
  12. "description": "Efficient skill management with progressive discovery — 410+ production-ready skills across 33+ domains.",
  13. "version": "4.0.0"
  14. }
  15. ]
  16. }
README.md · README · 548 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Atomic Skills for Claude Code
  2. [![Claude Code Plugin](https://img.shields.io/badge/Claude%20Code-Plugin-blue)](https://docs.claude.com/en/docs/claude-code/plugins)
  3. [![Skills](https://img.shields.io/badge/Skills-410%2B-green)](skills/)
  4. [![License](https://img.shields.io/badge/License-MIT-yellow)](LICENSE)
  5. **Context-efficient development knowledge via progressive skill discovery**
  6. ## New? Start Here
  7. **Install in 30 seconds**:
  8. ```
  9. /plugin marketplace add rand/cc-polymath
  10. /plugin install cc-polymath@cc-polymath
  11. ```
  12. **Your first 3 commands**:
  13. ```bash
  14. /skills # See what's recommended for your project
  15. /discover-frontend # Load React, Next.js, TypeScript skills (example)
  16. bash scripts/verify-install.sh # Verify installation
  17. ```
  18. **Learn more**:
  19. - 📖 **[Getting Started Guide](docs/GETTING_STARTED.md)** - 5-minute quick start
  20. - 💬 **[Example Conversations](docs/FIRST_CONVERSATIONS.md)** - See it in action
  21. - 🆘 **[Troubleshooting](docs/TROUBLESHOOTING.md)** - Common issues & solutions
  22. - ❓ **[FAQ](docs/FAQ.md)** - Quick answers
  23. ---
  24. This repository solves a tradeoff problem: how to give Claude Code access to comprehensive development knowledge without overwhelming its context window on boot. The solution is atomic, composable skills organized through a multi-tier discovery system.
  25. ## The Problem: Context vs Coverage
  26. Using the default mechanism with many atomic skills yields a dilemma:
  27. - **Load everything upfront** → 25K+ tokens consumed before any real work begins
  28. - **Load nothing** → Claude lacks essential patterns and best practices
  29. - **Manual loading** → Users must know what exists to ask for it
  30. This creates an challenging tradeoff between comprehensive coverage and context efficiency.
  31. ## The Solution: Atomic Skills + Progressive Discovery
  32. ### Atomic Skills (410+ total)
  33. Each skill is **focused, self-contained, and composable**:
  34. - Average 320 lines - small enough to load quickly
  35. - Single responsibility - covers one clear topic
  36. - Production-tested - real patterns from building at scale
  37. - Cross-referenced - links to related skills for composition
  38. **Why atomic matters**: Loading 5 focused skills (1.5K tokens) beats loading one monolithic guide (8K tokens) when you only need specific knowledge. Granularity enables precision.
  39. ### Three-Tier Architecture
  40. **Tier 1: Gateway Skills (23 auto-discovered Agent Skills)**
  41. Lightweight entry points that activate automatically based on keywords:
  42. - `discover-api` → triggers on "REST", "GraphQL", "authentication"
  43. - `discover-database` → triggers on "PostgreSQL", "MongoDB", "Redis"
  44. - `discover-zig` → triggers on "Zig", "comptime", "allocators"
  45. Each gateway is ~200 lines with quick reference and loading commands.
  46. **Tier 2: Category Indexes (30 detailed references)**
  47. Full skill listings with descriptions, use cases, and workflows:
  48. - `api/INDEX.md` → All 7 API skills with integration patterns
  49. - `database/INDEX.md` → All 11 database skills with decision trees
  50. - Only loaded when browsing or planning work
  51. **Tier 3: Individual Skills (on-demand)**
  52. Complete implementation guides loaded only when needed:
  53. - `api/rest-api-design.md` → Full REST patterns
  54. - `database/postgres-query-optimization.md` → EXPLAIN plans, indexes
  55. ### Why This Works
  56. **Context efficiency**: 60-84% reduction vs monolithic index
  57. - Old approach: Load 25K token index on boot
  58. - New approach: Load 2-5K tokens of relevant gateways as needed
  59. - Result: More context available for actual code and conversation
  60. **No boot overhead**: Claude Code starts with zero skills loaded
  61. - Gateway skills auto-discover based on your prompt keywords
  62. - Manual loading available when auto-discovery isn't enough
  63. - System scales to hundreds more skills without boot cost
  64. **Discoverability**: Users don't need to know what exists
  65. - Keywords in prompts trigger relevant gateways automatically
  66. - Gateways show what's available in their domain
  67. - Progressive loading: gateway → index → specific skill
  68. ## What's Covered
  69. ### Core Development (125 skills)
  70. **Languages & Frameworks**:
  71. - **Backend**: Python (uv), Zig, Rust, Go (31 skills)
  72. - **Frontend**: React, Next.js, TypeScript, Elegant Design (9 skills)
  73. - **Mobile**: SwiftUI, Swift concurrency, SwiftData, React Native (10 skills)
  74. **Infrastructure & DevOps**:
  75. - **Build Systems**: Make, CMake, Gradle, Maven, Bazel, cross-platform (8 skills)
  76. - **Debugging**: GDB, LLDB, Python, browser, memory, concurrency, production, distributed systems (14 skills)
  77. - **Cloud**: AWS (7), GCP (6), Modal.com, Cloudflare Workers, Vercel (13 skills)
  78. - **Containers**: Docker, Kubernetes, security (5 skills)
  79. - **CI/CD**: GitHub Actions, pipelines (4 skills)
  80. - **Observability**: Logging, metrics, tracing, OpenTelemetry, incident response (8 skills)
  81. **Data & APIs**:
  82. - **Databases**: Postgres, MongoDB, Redis, Redpanda, Iceberg, DuckDB (11 skills)
  83. - **Caching**: Multi-layer (browser, HTTP, CDN, Redis), invalidation strategies (7 skills)
  84. - **API Design**: REST, GraphQL, auth, rate limiting, versioning (7 skills)
  85. - **Data Engineering**: ETL, streaming, batch processing (5 skills)
  86. - **Testing**: Unit, integration, e2e, TDD, coverage (6 skills)
  87. ### Specialized Domains (85 skills)
  88. **Machine Learning & AI** (33 skills):
  89. - **LLM Evaluation**: Benchmarks (MMLU, HellaSwag), frameworks (Arize Phoenix, Braintrust), LLM-as-judge (Prometheus, G-Eval), RAGAS metrics
  90. - **Model Routing**: RouteLLM, model comparison, multi-model orchestration
  91. - **Advanced RAG**: Hybrid search, reranking (cross-encoder, LLM), GraphRAG, hierarchical retrieval
  92. - **DSPy Framework**: Signatures, modules, optimizers, RAG, assertions (7 skills)
  93. - **HuggingFace**: Hub, Transformers, Datasets, Spaces, AutoTrain (5 skills)
  94. - **Fine-tuning**: Unsloth, LoRA/PEFT, dataset prep (3 skills)
  95. **Rust & PyO3** (19 skills):
  96. - **DSPy-PyO3 Integration**: RAG pipelines, agents, async streaming, production deployment, optimization (7 skills with 36 production examples)
  97. - **Performance**: GIL management, parallel execution, data science, collections/iterators (6 skills)
  98. - **Web**: Axum frameworks, streaming responses, IPC, gRPC (2 skills)
  99. - **Production**: Packaging, testing, debugging, modules/functions/errors (4 skills with 20 examples)
  100. **Information Retrieval** (5 skills):
  101. - Search fundamentals (TF-IDF, BM25, Elasticsearch)
  102. - Vector search (dense retrieval, embeddings)
  103. - Ranking & reranking (learning to rank, cross-encoders)
  104. - Recommendation systems (collaborative, content-based, hybrid)
  105. - Query understanding (expansion, spell correction, semantic search)
  106. **Programming Language Theory** (13 skills):
  107. - Lambda calculus, type systems, dependent types
  108. - Curry-Howard correspondence, operational semantics
  109. - Program verification with Hoare logic
  110. - **Typed Holes & Live Programming**: Hazel/Hazelnut calculus, incremental typing
  111. - **AI-Assisted Programming**: LLM + typed holes integration (OOPSLA 2024), type-driven code synthesis
  112. **Formal Methods** (10 skills):
  113. - **SAT/SMT Solvers**: Z3 basics, SAT strategies, SMT theory (3 skills)
  114. - **Lean 4**: Proof basics, tactics, mathlib4, theorem proving (4 skills)
  115. - **Constraint Satisfaction**: CSP modeling, propagation, backtracking (3 skills)
  116. **Advanced Mathematics** (11 skills):
  117. - **Numerical**: Linear algebra, optimization, probability/statistics (4 skills)
  118. - **Pure Math**: Topology (point-set, algebraic), category theory, differential equations, abstract algebra, set theory, number theory (7 skills)
  119. **Systems Programming** (8 skills):
  120. - **WebAssembly**: Fundamentals, Rust toolchain, browser integration, server-side (4 skills)
  121. - **eBPF**: Fundamentals, tracing/observability, networking, security monitoring (4 skills)
  122. **Collaboration & Process** (14 skills):
  123. - **GitHub**: Repository management, pull requests, issues/projects, security, Actions (5 skills)
  124. - **PRD Writing**: Structure, requirements gathering, user stories, technical specs (4 skills)
  125. - **RFC Writing**: Structure, technical design, consensus building, decision docs (4 skills)
  126. **Real-time & Networking** (5 skills):
  127. - WebSocket, Server-Sent Events, pub/sub patterns
  128. - Tailscale VPN, mTLS, NAT traversal, Mosh
  129. - Network resilience patterns
  130. ### Workflow & Meta Skills (7 skills)
  131. - **Beads**: AI-native task management, context strategies, multi-session workflows (4 skills)
  132. - **TUI Development**: Bubble Tea (Go), Ratatui (Rust) (5 skills)
  133. - **Skill Discovery**: Intelligent skill activation for repos and prompts (5 skills)
  134. - **Anti-Slop**: Detection and cleanup of AI-generated patterns (Agent Skill)
  135. - **Elegant Design**: World-class accessible interfaces, design systems (Agent Skill)
  136. - **Typed Holes Refactor**: Systematic TDD-based refactoring (Agent Skill)
  137. ## Quick Start
  138. ### Installation
  139. **As Claude Code Plugin (Recommended)**:
  140. ```bash
  141. /plugin install https://github.com/rand/cc-polymath
  142. ```
  143. That's it! All 410+ skills and the `/skills` command are immediately available.
  144. **For local development or testing**:
  145. ```bash
  146. /plugin install /Users/rand/src/cc-polymath
  147. ```
  148. ### Auto-Discovery (How It Works)
  149. Just start working. Claude Code automatically activates relevant gateway skills based on your task keywords.
  150. **Example**: Mention "REST API with PostgreSQL" → `discover-api` and `discover-database` gateways activate automatically.
  151. ### Manual Loading
  152. When you need to browse or plan:
  153. ```bash
  154. # Browse skills catalog
  155. cat skills/README.md
  156. # View a category
  157. cat skills/api/INDEX.md # All API skills
  158. cat skills/database/INDEX.md # All database skills
  159. # Load a gateway
  160. cat skills/discover-ml/SKILL.md # ML gateway with quick reference
  161. # Load specific skills
  162. cat skills/api/rest-api-design.md
  163. cat skills/database/postgres-query-optimization.md
  164. ```
  165. ### Composing Workflows
  166. Skills are designed to combine for complex workflows:
  167. **Full-stack web app**:
  168. ```bash
  169. cat skills/api/rest-api-design.md
  170. cat skills/frontend/nextjs-app-router.md
  171. cat skills/database/postgres-schema-design.md
  172. cat skills/caching/redis-caching-patterns.md
  173. cat skills/cicd/github-actions-workflows.md
  174. ```
  175. **ML deployment with DSPy**:
  176. ```bash
  177. cat skills/ml/dspy-setup.md
  178. cat skills/ml/dspy-modules.md
  179. cat skills/modal/modal-gpu-workloads.md
  180. cat skills/modal/modal-web-endpoints.md
  181. cat skills/observability/structured-logging.md
  182. ```
  183. **Multi-layer caching strategy**:
  184. ```bash
  185. cat skills/caching/caching-fundamentals.md
  186. cat skills/caching/service-worker-caching.md # Browser
  187. cat skills/caching/http-caching.md # HTTP layer
  188. cat skills/caching/cdn-edge-caching.md # CDN edge
  189. cat skills/caching/redis-caching-patterns.md # Application
  190. cat skills/caching/cache-invalidation-strategies.md
  191. ```
  192. **iOS app with streaming backend**:
  193. ```bash
  194. cat skills/mobile/swiftui-architecture.md
  195. cat skills/mobile/swift-concurrency.md
  196. cat skills/mobile/swiftdata-persistence.md
  197. cat skills/mobile/ios-networking.md
  198. cat skills/database/redpanda-streaming.md
  199. ```
  200. ## Repository Structure
  201. ```
  202. .
  203. ├── CLAUDE.md # Development guidelines & protocols
  204. │ # - Multi-agent orchestration
  205. │ # - Work Plan Protocol (4 phases)
  206. │ # - Language standards (uv, cargo, zig)
  207. │ # - Testing protocols
  208. │ # - Anti-patterns
  209. │
  210. ├── README.md # This file
  211. │
  212. └── skills/ # 283 atomic skills, 31 gateways, 30 categories
  213. │
  214. ├── README.md # Skills catalog
  215. │
  216. ├── Gateway Skills (31 auto-discovered Agent Skills)
  217. │ ├── discover-api/ # REST, GraphQL, authentication
  218. │ ├── discover-database/ # PostgreSQL, MongoDB, Redis
  219. │ ├── discover-frontend/ # React, Next.js, UI components
  220. │ ├── discover-ml/ # Machine learning, models
  221. │ ├── discover-math/ # Mathematics, algorithms
  222. │ ├── discover-plt/ # Programming language theory
  223. │ ├── discover-formal/ # Formal methods, verification
  224. │ ├── discover-cloud/ # Serverless, cloud platforms
  225. │ ├── discover-zig/ # Zig systems programming
  226. │ ├── discover-networking/ # SSH, mTLS, VPN, resilience
  227. │ ├── discover-workflow/ # Beads, context strategies
  228. │ └── ... 20 more gateways
  229. │
  230. ├── Category Indexes (30 detailed references)
  231. │ ├── api/INDEX.md # All API skills overview
  232. │ ├── database/INDEX.md # All database skills overview
  233. │ ├── ml/INDEX.md # All ML skills overview
  234. │ └── ... 27 more indexes
  235. │
  236. └── Skills by Category
  237. ├── api/ # REST, GraphQL, auth (7)
  238. ├── database/ # Postgres, MongoDB, Redis, streaming (11)
  239. ├── frontend/ # React, Next.js, performance (8)
  240. ├── mobile/ # iOS/Swift, SwiftUI, SwiftData (10)
  241. ├── testing/ # Unit, integration, e2e (6)
  242. ├── caching/ # Multi-layer caching (7)
  243. ├── build-systems/ # Make, CMake, Gradle, Maven, Bazel (8)
  244. ├── debugging/ # GDB, LLDB, production, memory (14)
  245. ├── cloud/ # AWS, GCP, Modal, serverless (13)
  246. ├── containers/ # Docker, Kubernetes (5)
  247. ├── cicd/ # GitHub Actions, pipelines (4)
  248. ├── observability/ # Logging, metrics, tracing (8)
  249. ├── ml/ # DSPy, HuggingFace, LLM, RAG (30)
  250. ├── ir/ # Information retrieval (5)
  251. ├── math/ # Linear algebra, topology, category theory (19)
  252. ├── plt/ # Type systems, verification, typed holes (13)
  253. ├── formal/ # SAT/SMT, Lean, CSP (10)
  254. ├── wasm/ # WebAssembly (4)
  255. ├── ebpf/ # eBPF kernel programming (4)
  256. ├── networking/ # SSH, mTLS, VPN, NAT traversal (5)
  257. ├── tui/ # Terminal UI: Bubble Tea, Ratatui (5)
  258. ├── zig/ # Zig systems programming (6)
  259. ├── rust/ # Rust & PyO3: DSPy integration, performance, production (19)
  260. ├── workflow/ # Beads task management (4)
  261. ├── data/ # ETL, streaming, batch (5)
  262. ├── deployment/ # Heroku, Netlify (6)
  263. ├── realtime/ # WebSocket, SSE, pub/sub (4)
  264. ├── collaboration/ # GitHub, CodeTour (6)
  265. ├── product/ # PRD writing (4)
  266. ├── engineering/ # RFC writing (4)
  267. ├── infrastructure/# Terraform, Cloudflare Workers (6)
  268. │
  269. ├── Agent Skills (Root)
  270. │ ├── anti-slop/ # AI slop detection & cleanup
  271. │ ├── elegant-design/ # World-class UI design
  272. │ └── typed-holes-refactor/ # Systematic refactoring
  273. │
  274. └── Meta Skills (Root)
  275. ├── skill-repo-discovery.md # Analyze repos for skills
  276. ├── skill-prompt-discovery.md # Extract signals from prompts
  277. ├── skill-creation.md # Create new skills
  278. └── skill-*-planning.md # Planning workflows
  279. ```
  280. ## Technology Coverage
  281. | Domain | Technologies | Skills | Gateway |
  282. |--------|-------------|--------|---------|
  283. | **Backend** | Python, Zig, Rust, Go | 18 | discover-backend |
  284. | **Frontend** | React, Next.js, TypeScript | 9 | discover-frontend |
  285. | **Mobile** | SwiftUI, Swift, React Native | 10 | discover-mobile |
  286. | **Build** | Make, CMake, Gradle, Maven, Bazel | 8 | discover-cicd |
  287. | **Debug** | GDB, LLDB, pdb, DevTools, Valgrind | 14 | discover-debugging |
  288. | **Cloud** | AWS, GCP, Modal, Vercel, Cloudflare | 27 | discover-infra |
  289. | **Database** | Postgres, Mongo, Redis, Redpanda, Iceberg | 11 | discover-database |
  290. | **Caching** | Redis, HTTP, CDN, Service Workers | 7 | discover-database |
  291. | **ML/AI** | DSPy, HuggingFace, Arize, GraphRAG | 33 | discover-ml |
  292. | **Rust/PyO3** | DSPy integration, RAG, agents, async, production | 19 | N/A |
  293. | **IR** | Elasticsearch, Vector DBs, Ranking | 5 | discover-systems-theory |
  294. | **Systems** | WebAssembly, eBPF | 8 | discover-wasm, discover-systems-theory |
  295. | **Collaboration** | GitHub, PRD, RFC | 17 | discover-product, discover-product, discover-engineering |
  296. | **Formal** | Z3, Lean 4, CSP | 10 | discover-systems-theory |
  297. | **Math** | Linear algebra, topology, category theory | 19 | discover-math |
  298. | **PLT** | Lambda calculus, type systems, typed holes | 13 | discover-systems-theory |
  299. | **DevOps** | GitHub Actions, Terraform, K8s, Docker | 16 | discover-cicd, discover-infra, discover-infra |
  300. | **Observability** | Prometheus, OpenTelemetry, Grafana | 8 | discover-debugging |
  301. | **Networking** | SSH, mTLS, VPN, Tailscale, NAT | 5 | discover-networking |
  302. | **TUI** | Bubble Tea, Ratatui | 5 | discover-frontend |
  303. | **Zig** | Build systems, C interop, memory management | 6 | discover-zig |
  304. | **Workflow** | Beads, context strategies | 4 | discover-product |
  305. ## Development Philosophy
  306. ### Atomic & Composable
  307. - **Focused**: Each skill covers one topic (~320 lines)
  308. - **Self-contained**: Can be loaded independently
  309. - **Cross-referenced**: Links to related skills
  310. - **Production-tested**: Real patterns from building at scale
  311. ### Progressive Discovery
  312. - **Zero boot cost**: No skills loaded until needed
  313. - **Automatic activation**: Gateway skills trigger on keywords
  314. - **Manual override**: Browse and load specific skills
  315. - **Context efficient**: Load only what's relevant
  316. ### Quality Standards
  317. - ✅ **Code Block Validation**: 1100+ blocks syntax-checked
  318. - ✅ **Frontmatter Validation**: 283 skills with YAML metadata
  319. - ✅ **Date Validation**: No future dates in "Last Updated"
  320. - ✅ **CI/CD Pipeline**: Automated validation on every commit
  321. - ✅ **Cross-References**: Related skills linked for discoverability
  322. ## CLAUDE.md Development Guidelines
  323. This repository includes comprehensive development guidelines in `CLAUDE.md`:
  324. - **Multi-Agent Orchestration**: Coordinated system with Orchestrator, Optimizer, Reviewer, Executor
  325. - **Work Plan Protocol**: 4-phase development (Prompt→Spec→Full Spec→Plan→Artifacts)
  326. - **Beads Workflow**: AI-native task management with dependencies
  327. - **Language Standards**: Correct tools (uv not pip, etc.)
  328. - **Testing Protocol**: Commit before testing (mandatory)
  329. - **Anti-Patterns**: Critical violations and recovery procedures
  330. ## Example Use Cases
  331. ### Build ML-powered API
  332. ```bash
  333. cat skills/ml/dspy-setup.md # Configure DSPy
  334. cat skills/ml/dspy-modules.md # Build RAG pipeline
  335. cat skills/ml/dspy-optimizers.md # Optimize prompts
  336. cat skills/modal/modal-gpu-workloads.md # Deploy on GPU
  337. cat skills/modal/modal-web-endpoints.md # Expose API
  338. cat skills/api/rest-api-design.md # Design contract
  339. cat skills/api/api-rate-limiting.md # Protect endpoint
  340. ```
  341. ### Formal Verification
  342. ```bash
  343. cat skills/plt/type-systems.md # Type soundness
  344. cat skills/plt/dependent-types.md # Π-types, Σ-types
  345. cat skills/plt/program-verification.md # Hoare logic
  346. cat skills/formal/lean-proof-basics.md # Formalize in Lean
  347. cat skills/formal/z3-solver-basics.md # SMT checking
  348. ```
  349. ### AI-Assisted Programming
  350. ```bash
  351. cat skills/plt/typed-holes-foundations.md # Gradual typing
  352. cat skills/plt/typed-holes-llm.md # LLM integration
  353. cat skills/plt/live-programming-holes.md # Real-time feedback
  354. ```
  355. ### Multi-Layer Caching
  356. ```bash
  357. cat skills/caching/caching-fundamentals.md # Core patterns
  358. cat skills/caching/service-worker-caching.md # Browser layer
  359. cat skills/caching/http-caching.md # HTTP layer
  360. cat skills/caching/cdn-edge-caching.md # CDN layer
  361. cat skills/caching/redis-caching-patterns.md # Application layer
  362. cat skills/caching/cache-invalidation-strategies.md # Invalidation
  363. cat skills/caching/cache-performance-monitoring.md # Monitoring
  364. ```
  365. ## Level 3 Resources: Production-Ready Tools & References
  366. **In Progress**: Building comprehensive Level 3 Resources for high-priority skills.
  367. ### What Are Level 3 Resources?
  368. Each skill follows Anthropic's agent skills framework with three progressive levels:
  369. - **Level 1**: Skill file (300-400 lines) - Core concepts, patterns, quick reference
  370. - **Level 2**: Category INDEX - Detailed listings and workflows
  371. - **Level 3**: Resources directory - Production tools, comprehensive references, examples
  372. **Level 3 Resources** transform skills from guides into executable toolkits:
  373. **REFERENCE.md** (1,500-4,000 lines):
  374. - Comprehensive technical documentation
  375. - Architecture patterns and best practices
  376. - Troubleshooting guides and anti-patterns
  377. - Integration examples and production patterns
  378. **Scripts** (3 per skill, 550-800+ lines each):
  379. - Production-ready Python tools
  380. - Executable with `--help` and `--json` support
  381. - Type hints and comprehensive error handling
  382. - No TODOs or placeholders - fully implemented
  383. **Examples** (7-10 per skill):
  384. - Production-ready code across multiple languages/platforms
  385. - Complete implementations with error handling
  386. - Docker Compose setups, CI/CD workflows
  387. - Monitoring and observability configurations
  388. ### Progress: Waves 1-10 Complete
  389. **Status**: 48/123 HIGH priority skills have Level 3 Resources (39%)
  390. #### Recent Completion (Waves 9-10)
  391. **Wave 9** (6 skills, +51,979 lines):
  392. - **Cryptography**: signing-verification, hsm-integration
  393. - **Protocols**: amqp-rabbitmq, protobuf-schemas
  394. - **Engineering**: sre-practices, feature-flags
  395. **Wave 10** (2 skills, +14,375 lines):
  396. - **Cryptography**: secrets-rotation (completes 6/7 in category)
  397. - **Protocols**: http3-quic
  398. #### Strategic Focus: Zero-Coverage Categories
  399. **Target**: 28 skills across Cryptography, Protocols, Engineering
  400. **Progress**: 18/28 complete (64%)
  401. **Cryptography**: 6/7 complete (86%)
  402. - ✅ encryption-at-rest, key-management, certificate-management, hsm-integration, signing-verification, secrets-rotation
  403. - ⏳ pki-fundamentals (60% complete)
  404. **Protocols**: 6/8 complete (75%)
  405. - ✅ grpc-implementation, kafka-streams, mqtt-messaging, amqp-rabbitmq, protobuf-schemas, http3-quic
  406. - ⏳ websocket-protocols (15% complete)
  407. - ⏳ tcp-optimization
  408. **Engineering**: 6/14 complete (43%)
  409. - ✅ deployment-strategies, e2e-testing, monitoring-alerts, incident-response, sre-practices, feature-flags
  410. - ⏳ ci-cd-pipelines (10% complete), capacity-planning (5% complete)
  411. - ⏳ 6 more skills
  412. ### Methodology
  413. **Hybrid Approach**: Combines manual quality control with template-based acceleration
  414. - 24-35 completed skills serve as templates
  415. - Pattern consistency enforced via quality gates
  416. - 40-50% faster than pure manual while maintaining standards
  417. - 6 parallel agents per wave (optimal throughput)
  418. **Quality Gates** (enforced before commit):
  419. - REFERENCE.md: 1,500-4,000 lines
  420. - Scripts: 3 per skill, executable, --help/--json support, type hints
  421. - Examples: 7-10 per skill, production-ready, no placeholders
  422. - No TODO/stub/mock comments anywhere
  423. - CI validation on all PRs
  424. ### CI/CD Integration
  425. Automated validation runs on all resource changes:
  426. - REFERENCE.md line count validation
  427. - Script executability and shebang checks
  428. - TODO/stub/mock comment detection
  429. - Python syntax validation for examples
  430. - Full validation results in PR comments
  431. See `.github/workflows/validate-resources.yml` for details.
  432. ### Future Waves
  433. **Next Sessions** (tracked in `.work/WAVE_10_INCOMPLETE.md`):
  434. - Complete 4 partial Wave 10 skills (pki-fundamentals, websocket-protocols, ci-cd-pipelines, capacity-planning)
  435. - 6 additional skills to reach 100% strategic focus coverage
  436. - Estimated: 30-40 hours across 2-3 sessions
  437. **Long-term**: 75+ additional skills need Level 3 Resources to reach comprehensive coverage
  438. ## Contributing
  439. This is a personal reference repository maintained through practical development experience. Skills are added when new technologies are mastered, updated when better patterns emerge, and refined based on production use.
  440. Feel free to fork and adapt for your own use. Pull requests welcome.
  441. ---
  442. **410+ atomic skills** • **23 gateway Agent Skills** • **33+ categories** • **100% CI-validated**

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.