tachyon-beep-skillpacks

Plugin tachyon-beep-skillpacks from marketplace cascade-code-general-misc-4 in joshuarweaver/cascade-code-general-misc-4. Commands read from the repo's manifest — 1 month ago.

Skills (64)

• filigree-workflow

  This skill should be used when the user asks to "track work", "create an issue", "find something to work on", "what should I work on next", "triage bugs", "close an issue", "check what's blocked", "plan a milestone", "review sprint progress", "coordinate agents", or when working in a project that us

• using-audit-pipelines

  Use when a system makes procedural decisions that must be defensible after the fact — rule firings, governor decisions, state transitions, gate verdicts, eligibility determinations, automated approvals — and you need a verifiable provenance chain rather than ordinary observability. Use when an audit

• using-contract-engineering

  Use when designing, evolving, or reviewing **typed contracts between subsystems** — the records that cross authority boundaries in a pipeline, service mesh, or multi-stage system. Use when a consumer crashed on a missing field and the proposed fix is a default or a lenient reader; when a schema is c

• using-determinism-and-replay

  Use when designing a system whose past behaviour must be recoverable as a fact — RL training substrates, multi-agent simulations, deterministic game engines, replay-debuggable services, multiplayer lockstep, or any pipeline where "I cannot reproduce that bug" is unacceptable. Use when teams disagree

• using-devops-engineering

  Use when building or fixing the path from commit to running production — CI/CD pipelines and verification gates, zero-downtime deployment, infrastructure as code, container build hygiene, Kubernetes/orchestration runtime, observability (metrics/logs/traces, SLI/SLO), incident response and on-call, r

• using-distributed-systems

  Use when designing a system that spans more than one process, machine, or failure domain and a partition, crash, or duplicate must not silently corrupt state. Use when you see split-brain, lost writes under partition, duplicate processing, stuck or half-applied sagas, retry storms, dual writes drift

• using-embedded-database

  Use when running **SQLite or DuckDB inside an application process** as the durable store — not as a development convenience but as the production database. Use when scaling an SQLite layer that worked at low concurrency and is now hitting SQLITE_BUSY, WAL bloat, lock contention, schema-migration cer

• using-software-engineering

  Use when facing complex engineering challenges that require systematic methodology - horrible bugs, safe refactoring, code review, production incidents, technical debt decisions, or building confidence in unfamiliar codebases

• using-experiment-formalisation

  Use when formalising an experiment as a machine-checkable record layer using scientific-experiment ontologies — EXPO (Soldatova & King's ontology of scientific experiments), SUMO or BFO as upper ontology, PROV-O for lineage. Use when handed a mapping of your system onto EXPO and asked to check or ex

• using-mcp-engineering

  Use when designing, implementing, or auditing an MCP (Model Context Protocol) server — tool API design, idempotency under agent retry, structured error envelopes agents can recover from, schema versioning across model drift, transport reliability (stdio / HTTP), output-shape and pagination disciplin

• implementation-planning

  Use when you have specifications or requirements for multi-step implementation tasks requiring comprehensive documentation for handoff

• plan-review

  Use after implementation-planning to validate plans against codebase reality, risk, complexity, and project conventions before execution

• using-procedural-architecture

  Use when designing or critiquing the structure of a staged procedure — a wizard, configuration flow, troubleshooting tree, training curriculum, multi-stage approval pipeline, decision pipeline, or any decomposition of expert work into composable stages. Use for both producer work (build the decompos

• using-product-management

  Use when a Claude is taking **standing ownership** of a software product across many sessions — discovery, strategy, specs, and value validation — deciding *what to build, why, for whom,* and *whether it worked*, with continuity, decision provenance, and an authority boundary that escalates irrevers

• using-program-management

  Use when **managing the delivery of work** rather than building it — running a project or a program, not writing its code. Use when a team is busy but outcomes are not landing, when "when will it be done" has no defensible answer, when status is green every week until it is suddenly red, when depend

• using-pyo3-interop

  Use when building or maintaining a **PyO3 extension module** — a Rust crate exposed to Python as an importable extension. Use when scaling a PyO3 prototype that worked at low call rates and is now in a hot loop (RL self-play, batched inference, real-time pipeline). Use when the boundary symptom is G

• using-python-engineering

  Use when working on a Python task and unsure which specialist to load - routes to type-system, mypy-resolution, project-tooling, delinting, testing, async, scientific-computing, ML-workflows, debugging-and-profiling, or Textual-TUI specialists based on symptoms

• using-rust-engineering

  Use when working in Rust — routes to specialist sheets for borrow-checker errors (E0502/E0597/E0382), trait bounds (E0277), async Send/Sync, clippy warnings, unsafe/FFI soundness, performance profiling, or PyO3/candle interop

• using-rust-workspaces

  Use when working in a Rust **cargo workspace** — multiple crates under one `[workspace]` root, shared `Cargo.lock`, shared target dir. Use when promoting a single-crate project to a workspace, when crates have drifted into per-crate dependency versions / lint configs / licence policies, when feature

• design-and-build

  Use when making architecture decisions, setting up CI/CD, managing technical debt, or choosing branching strategies - enforces ADR requirements and prevents resume-driven design

• governance-and-risk

  Use when making architectural decisions without documentation, skipping risk analysis, accepting risks without mitigation, or treating governance as optional bureaucracy - enforces mandatory DAR/RSKM based on project risk level

• lifecycle-adoption

  Use when starting new projects with CMMI, adding CMMI to active development, preparing for audits, migrating tools, or facing team resistance to process adoption

• platform-integration

  Use when implementing CMMI processes in GitHub or Azure DevOps, migrating between platforms, or establishing traceability/compliance on GitHub/Azure - platform-specific process guidance

• quality-assurance

  Use when deciding test strategy, struggling with code reviews, shipping without tests, or conflating verification with validation

• quantitative-management

  Use when establishing measurement programs, analyzing metrics with statistical process control, setting baselines, or implementing CMMI Level 4 quantitative management - prevents vanity metrics and measurement theater

• requirements-lifecycle

  Use when defining requirements, tracking traceability, managing requirement changes, or establishing RTM - covers elicitation, analysis, specification across CMMI Levels 2-4

• using-sdlc-engineering

  Use when users request SDLC guidance, CMMI processes, requirements management, design documentation, quality assurance, governance, metrics, or adopting processes on existing projects

• using-solution-architect

  Routes a design brief, HLD, epic, or brownfield change through the full solution-architecture workflow — triage, NFR quantification, tech selection, ADRs, traceability, integration/migration, optional TOGAF/ArchiMate, and consolidated SAD with consistency gate

• using-static-analysis-engineering

  Use when designing or extending a static analyzer — a linter, a taint tracker, a contract checker, an entity extractor, a governance rule engine, or any tool that reads source code and produces verdicts about it without running the program. Use when adding typed dataflow (taint, ownership, capabilit

• using-system-archaeologist

  Use when analyzing existing codebases to generate architecture documentation - coordinates subagent-driven exploration with mandatory workspace structure, validation gates, and pressure-resistant workflows

• using-system-architect

  Use when you have architecture documentation from system-archaeologist and need critical assessment, refactoring recommendations, or improvement prioritization - routes to appropriate architect specialist skills

• using-tensor-compiler-engineering

  Use when building or auditing a compiler for tensor programs — lowering a graph IR to executable PyTorch, writing torch.fx passes, driving torch.compile/dynamo/inductor/AOTAutograd, selecting kernels, fusing operators, or planning memory. Use when compiled output differs from eager, gradients mismat

• using-web-backend

  Use when building web APIs, backend services, or encountering FastAPI/Django/Express/GraphQL questions, microservices architecture, authentication, or message queues - routes to 11 specialist skills rather than giving surface-level generic advice

• using-game-design

  Use when creating, analyzing, repairing, or iterating a game concept, mechanic, ruleset, core loop, session arc, economy, balance model, prototype, or playtest; translating a desired kind of fun, learning outcome, or player experience into tangible mechanics; diagnosing locally interesting ideas tha

• using-simulation-tactics

  Use when implementing or debugging game simulation - deciding what to simulate vs fake (scrutiny-based LOD), designing in-engine systems (physics, AI agents, pathfinding, economy, ecosystem, crowds, weather/time), optimising simulation under frame budget, or tracing chaos/desyncs/explosions. Routes

• using-systems-as-experience

  Router for systems-as-experience - emergence, sandbox, optimization, discovery, narrative, modding

• using-creative-writing

  Use when the user wants to draft fiction or creative nonfiction prose, get craft critique on prose they have written, or plan story structure, outline, or premise. Workshop-voiced. Three explicit modes (draft, critique, plan) and the router will refuse to begin work without a declared mode.

• using-site-designer

  Use when designing or implementing static websites for developer tools, open-source projects, or technical documentation — information architecture, HTML/CSS, design tokens, developer UX patterns

• using-tui-designer

  Use when designing, building, or reviewing a terminal user interface (TUI) — a full-screen or interactive terminal app — across any framework (ratatui/Rust, Textual+Rich/Python, Bubble Tea/Go, Ink/JS, ncurses/notcurses). Covers terminal substrate and capability detection, event-loop and state archit

• using-ux-designer

  Use when starting any UX/UI design task — visual design, IA, interaction, accessibility (WCAG 2.2), user research across mobile, web, desktop, game, and AI surfaces, plus first-principles audience-derived needs analysis. Routes to 11 specialist sheets.

• data-stuff

  For data

• data-things

  Helps with data stuff

• using-skillpack-maintenance

  Use when maintaining, enhancing, or modifying existing Claude Code plugins - handles skills, commands, agents, hooks, and reference sheets through systematic domain analysis, structure review, behavioral testing, and quality improvements

• sme-agent-protocol

  Mandatory protocol for all SME (Subject Matter Expert) agents. Defines fact-finding requirements, output contracts, confidence/risk assessment, and qualification of advice.

• using-document-designer

  Use when creating professional documents, PDF reports, Typst templates, Pandoc conversions, or any task where document visual design quality matters

• reader-panel-review

  Orchestrate a simulated reader panel review — spawn persona-reader agents as teammates, manage the chapter pump, enforce the Step A gate, and coordinate synthesis

• fact-checking

  Use when fact-checking a research paper or document - dual-verified web search with claim extraction, independent researcher and adversarial verifier, structured JSON output and human-readable exception report. Invoke explicitly via /fact-check; expensive operation.

• using-technical-writer

  Use when writing or improving documentation - ADRs, APIs, runbooks, READMEs, architecture docs, security/compliance docs, post-mortems, register review or translation (technical/policy/government/public-facing/executive/academic), fact-checking research papers, or surgical edits on large (>=2000 lin

• using-wiki-manager

  Use when managing multi-document sets as wikis - manifest-driven architecture, reading paths, derivation discipline, terminology/claim consistency, change evolution, and governance for standards suites, policy frameworks, and technical documentation collections

• using-quality-engineering

  Use when user asks about E2E testing, performance testing, chaos engineering, test automation, flaky tests, test data management, or quality practices - routes to specialist reference sheets with deep expertise instead of providing general guidance

• using-security-architect

  Use when designing or reviewing security architecture - threat modeling (STRIDE), defense-in-depth controls, secure-by-design patterns, LLM/AI security (OWASP LLM Top 10, MITRE ATLAS), supply-chain security (SLSA/SBOM/Sigstore), compliance mapping (NIST CSF/ISO 27001/PCI-DSS/GDPR), classified-system

• using-ai-engineering

  Use when you have an AI/ML task but aren't sure which Yzmir pack handles it - routes frameworks, training, RL, LLMs, architectures, and production to the correct specialist pack and clarifies before guessing

• using-counterfactual-statistics

  Use for counterfactual and paired-branch ML experiments - matched-seed comparisons, branch rollouts from a shared snapshot, ablation forests, best-of-K screening. Fires on "is this significant", "how many runs/seeds do I need", paired comparison, counterfactual evaluation, selection bias, winner's c

• using-deep-rl

  Use when training, debugging, or selecting a deep-RL algorithm — value-based (DQN/Rainbow/BBF), policy-gradient (PPO/GRPO), actor-critic (SAC/TD3/REDQ), model-based (DreamerV3/TD-MPC2), offline (CQL/IQL/Decision Transformer), multi-agent (MAPPO/IPPO), exploration, reward shaping, or counterfactual c

• using-dynamic-architectures

  Use when building networks that grow, prune, or adapt topology during training. Routes to continual learning, gradient isolation, modular composition, and lifecycle orchestration skills.

• using-llm-specialist

  Use when working on LLM applications — chat / instruct prompting, reasoning models (o-series / Claude extended thinking / DeepSeek-R1 / Gemini thinking / Qwen QwQ), agentic patterns + MCP, RAG, fine-tuning (SFT / DPO / IPO / KTO / SimPO / ORPO / GRPO + LoRA family), context engineering and prompt ca

• using-ml-production

  Router skill directing to deployment, optimization, MLOps, and monitoring guides.

• using-morphogenetic-rl

  Use when an RL controller decides whether/when/how to mutate a network's topology during training - growing seeds, grafting modules, retiring underperformers - and you need controller action/observation/reward design, governor and safety-gate discipline, rollback-as-RL-signal shaping, deterministic

• using-neural-architectures

  Use when selecting or comparing neural architectures - routes by data modality (vision / sequence / graph / generative / multimodal) and constraints (dataset size, compute, latency); covers CNNs (ConvNeXt v2 / EfficientNetV2), Transformers + MoE (Mixtral / DeepSeek), SSM/Mamba, modern diffusion (SDX

• using-pytorch-engineering

  Routes to appropriate PyTorch specialist skill based on symptoms and problem type

• using-simulation-foundations

  Router for simulation math - ODEs, state-space, stability, control, numerics, chaos, stochastic

• using-structure-synthesis

  Use when a model's OUTPUT is a graph or structure rather than a label or scalar - generating neural-architecture candidates, program-synthesis over typed IRs, molecule or circuit graphs, or any typed DAG emitted by a generator. Covers typed graph grammars with node/edge/cost ceilings, deterministic

• using-systems-thinking

  Use when a problem keeps recurring despite fixes, when interventions produce side effects or backfire, or when you need to find high-leverage interventions in a complex system - routes to systems-thinking methodology (patterns, leverage points, archetypes, stocks-flows, causal loops, BOT graphs)

• using-training-optimization

  Use when encountering training problems (loss not decreasing, instability, NaN, overfitting, slow training) or selecting training dynamics (optimizer / LR / schedule / batch / precision / clipping / regularization) — routes to specialist sheets for the 2026-era landscape (Lion, Sophia, Muon, AdEMAMi

MCP servers (1)

• filigree

  runs: /home/john/.local/bin/filigree-mcp

Similar plugins