Collected sources and patterns will appear here. Add from search or the patterns library.
The thing you actually install, composed from reusable patterns and attributed to the real projects they came from. A skill, a build spec, an MCP server, a config, a pipeline. Pull one into your project.
Scan a QR code to chat with your home's local LLM (Ollama/LM Studio) from any phone: auto-discovers the running server, tunnels it securely, no cloud accounts or port forwarding.
Built from 2 patterns
Turns everyday voice memos into searchable life records: CTC word-level timestamps plus human-readable event tags (laughter, bgm) parsed into a clean timeline.
Built from 2 patterns
Self-building Claude skill: turn a pile of structured logs into windowed metrics — counts, error rates, and latency percentiles as time-series — without a separate metrics pipeline. Tumbling windows, per-window error isolation, nearest-rank percentiles. Ships markdown only; the host agent builds the deriver and proves it against an embedded stdlib-only test (verified: catches global-vs-per-window error-rate bugs). Distilled from openobserve and timeplus/proton.
Built from 2 patterns
Self-building Claude skill: search and rewrite code by its syntax-tree STRUCTURE, not text — 'every call to X inside a try block', 'functions with more than N params', structural codemods and lint that regex cannot express. Python reference uses stdlib ast; tree-sitter for other languages. Ships markdown only; the host agent builds the matcher and proves it against an embedded stdlib-only test (verified: catches structure-blind regex builds). Distilled from tree-sitter.
Built from 1 pattern
Self-building Claude skill: turn a codebase into a prioritized supply-chain risk report. Resolves the dependency tree, mints a PURL per component, looks up known vulnerabilities (OSV.dev), and correlates components with advisories and fix status (VEX/VDR-style) to surface only the actionable set — not 'you have CVEs' but 'these are the ones that matter given what you ship.' Ships markdown only; the host agent builds the analyzer and proves it against an embedded, network-free acceptance test (verified: catches advisory-leak bugs). Distilled from platformio, DependencyTrack, and CycloneDX.
Built from 3 patterns
An installable Claude skill: when handed a folder of documents too large for one context window, build a local hybrid BM25 + vector index (plus an optional entity-relation graph) in the sandbox and answer questions grounded in retrieved chunks with citations, instead of skimming whatever fits.
Built from 2 patterns
An installable Claude skill: point it at a repository and it parses the actual ASTs to emit grounded architecture, dependency, and control-flow diagrams (Mermaid/Graphviz) instead of guessing structure from skimming. Addresses the universal 'I inherited this codebase, explain how it flows' request.
Built from 4 patterns
An installable Claude skill: turn any schema (SQL DDL, Pydantic, JSON Schema, OpenAPI, CSV header, or plain English) into realistic, referentially-consistent synthetic data — seed rows, test fixtures, demo datasets, mock payloads, load-test volume. Semantic-aware generators, order-respecting timestamps, no dangling foreign keys, schema-validated before emit, reproducible via printed seed. Ships with a verified reference generator.
Built from 2 patterns
Attested diff-promotion ledger: every AI-authored change is signed by the agent (Ed25519 + post-quantum), co-signed by a human approver, dual-verified before it lands, and appended to a tamper-evident ledger. Provenance/audit for AI-authored code (Zephyr SBOF model on diffs). Note: reference build mocks signatures with SHA256 and the ledger is not yet hash-chained. Star atom: composite-signature-verification on diffs.
Built from 4 patterns
AST-grounded code-intelligence plane: parse repo to ASTs, extract public ABIs, write symbols/dependencies to a knowledge graph, retrieve precise context via hybrid graph+vector search, and render the control-flow slice being edited. Grounds coding agents in real symbols instead of hallucinated APIs. Star atom: AST-to-ABI generation.
Built from 4 patterns
Sandbox-first execution plane for agentic coding: agent works in a disposable workspace provisioned from a manifest, and only operator-approved diffs are promoted back to the real repo. Blast-radius containment pattern. IMPORTANT: the reference build's sandbox is a temp-dir+subprocess, not real isolation — production requires gVisor/Firecracker/container. Star atom: declarative-sandbox-provisioning.
Built from 4 patterns
Fuel-metered runtime-control plane for autonomous coding agents. Each action spends a fuel budget; exhaustion traps to a safe-stop and routes to a human handoff (replenish or exit), with a live terminal trace of the burn. Resource governance / runaway prevention. Star atom: fuel-metered execution.
Built from 5 patterns
Layout-preserving document-intelligence pipeline. Two ingestion lanes (web markdown; layout-rich docs that keep their 2D bounding-box geometry) feed a rate-budgeted embedding stage, write to an entity-relation knowledge graph, and answer via hybrid graph+vector retrieval. Differentiator: table/form structure survives ingestion. Star atom: spatial-coordinate text embedding (LayoutLM).
Built from 5 patterns
Trust-gated self-extending agent tool runtime. Tools (remote MCP + local functions) are discovered at runtime but admitted only after composite classical+post-quantum signature verification; designated calls are gated by human approval. Runs on a graph substrate with conditional routing and reducer state. Star atom: composite-signature-verification between discovery and admission.
Built from 6 patterns
SPEC.md — Attested Discovery Ledger (ADL)
Built from 1 source
SPEC.md — Optical Neural Front-End (ONF) System
Built from 1 source