tachyon-beep

@tachyon-beep source repo

56 skills
0 followers
1 week ago last updated

▌
Using Training Optimization · tachyon-beep bundle
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, AdEMAMix, Schedule-Free, Prodigy, AdamW8bit, paged optimizers, WSD schedules, FP8 / BF16 precision, muP / mu-Transfer, ZeRO/FSDP strategy).

0 installs
▌
Using Systems As Experience · tachyon-beep bundle
Router for systems-as-experience - emergence, sandbox, optimization, discovery, narrative, modding

0 installs
▌
Using Determinism And Replay · tachyon-beep bundle
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 about what "snapshot", "seed", or "replay" mean across modules. Use when cross-machine or cross-process determinism is required, or a regulator will ask "what was the input at tick T?". Architecture-level — how to design a deterministic system. For verifying an existing simulation against known patterns, use `/check-determinism` from yzmir-simulation-foundations instead.

0 installs
▌
Using Procedural Architecture · tachyon-beep bundle
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 decomposition) and critic work (audit a proposed decomposition). Use when reasoning about capacity, bottlenecks, or soundness of a procedural flow. Do not use for implementation-plan critique of code changes (use `/axiom-planning` instead), for execution-time dynamics (use `/simulation-foundations`), or for rendering an already-designed procedure as docs or UI (use `/technical-writer` or `/ux-designer`).

0 installs
▌
Using Experiment Formalisation · tachyon-beep bundle
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 extend it; when results must be auditable, reproducible, or interoperable with another group; when someone proposes making a knowledge graph the source of truth for decisions; when experiment records cannot say what a result was compared against, which regime produced it, or whether a value was unmeasured rather than zero. NOT for Expo/React Native, and NOT for Eclipse SUMO traffic simulation.

0 installs
▌
Using Counterfactual Statistics · tachyon-beep bundle
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 curse, best-of-K, abstention calibration, data leakage between splits, pre-registration, Pareto frontier reporting, pseudo-replication. Covers the independent statistical unit (the trajectory, not the branch), cluster-robust inference, paired tests against a zero-anchored no-op control, common random numbers, grouped splits, multiple comparisons and sequential testing, paired power analysis, cost-charged utility, and reliability reporting.

0 installs
▌
Using Static Analysis Engineering · tachyon-beep bundle
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, capability) to a system that currently does pattern matching, when an inherited analyzer cannot be extended cleanly, when suppressions are growing faster than rules, or when choosing between static and runtime enforcement of a property. Engineering pack — how to build the analyzer. For consuming an existing analyzer's output to map a codebase, use `/system-archaeologist` instead.

0 installs
▌
Using Tensor Compiler Engineering · tachyon-beep bundle
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 mismatch after compilation, a numerical tolerance is being argued about, a compilation cache returns a stale or wrong artifact, or model builds must be reproducible. Covers semantic identity vs execution strategy, conformance gates independent of the compiler (reference execution, gradcheck, cross-device and cross-layout agreement), compilation manifests, content-addressed artifacts, compile-time budgets and staleness, and miscompile bisection. Producer-side pack — it transforms IR and emits executables. To read code and produce verdicts use `/static-analysis-engineering`; for run-versus-replay divergence use `/determinism-and-replay`.

0 installs
▌
Using Morphogenetic Rl · tachyon-beep bundle
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 replay across topology change, or growth-aware ablation/evaluation.

0 installs
▌
Using Systems Thinking · tachyon-beep bundle
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)

0 installs
▌
Using Document Designer · tachyon-beep bundle
Use when creating professional documents, PDF reports, Typst templates, Pandoc conversions, or any task where document visual design quality matters

0 installs
▌
Using Embedded Database · tachyon-beep bundle
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 ceremony, or correctness gaps under multi-process writers. Use when introducing DuckDB as an OLAP complement to an OLTP SQLite store, or when picking between the two for a new component. Pairs with `/web-backend` (the API surface above the DB) and `/audit-pipelines` (when the DB is also the audit trail). Do not load for server databases (Postgres, MySQL), key-value stores, or ORM choice in isolation.

0 installs
▌
Using AI Engineering · tachyon-beep bundle
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

0 installs
▌
Using Devops Engineering · tachyon-beep bundle
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, release management and rollback, secrets and configuration, environment parity and promotion, DevSecOps and software supply-chain security, GitOps/declarative delivery, and SRE/reliability — routes to 13 specialist reference sheets instead of giving surface-level generic ops advice.

0 installs
▌
Using Product Management · tachyon-beep bundle
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 irreversible or outward-facing actions to the human owner. Owns the product disciplines: opportunity assessment (JTBD, problem validation, business case), vision/strategy/positioning and intent-roadmapping, PRDs with falsifiable acceptance criteria, delivery orchestration and acceptance, product-value metrics and experimentation, and the product anti-pattern catalog. Orchestrates rather than reimplements: routes sequencing/flow/WSJF to `/program-management`, plans to `/axiom-planning`, solution/architecture to `/solution-architect`, research method to `/ux-designer`. Do **not** load to build one feature, choose an architecture, or manage delivery flow for already-decided work.

0 installs
▌
Using Program Management · tachyon-beep bundle
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 dependencies surprise you, when a RAID log is a graveyard, or when several projects must be coordinated toward one outcome (a program). Lean/agile-leaning, honest about where program scale needs predictive structure. Pairs with `/axiom-planning` (turning one workstream into an implementation plan) and `/sdlc-engineering` (process maturity, requirements traceability, formal governance). Do not load for writing code, picking an architecture, or designing a single feature.

0 installs
▌
Using Python Engineering · tachyon-beep bundle
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

0 installs
▌
Using Solution Architect · tachyon-beep bundle
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

0 installs
▌
Using Security Architect · tachyon-beep bundle
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-systems MLS, and government authorization (ATO/RMF/FedRAMP).

0 installs
▌
Using Simulation Tactics · tachyon-beep bundle
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 to 10 specialist sheets + 3 router-support sheets, 3 commands, 2 SME agents. For numerical-methods math and stability proofs use /simulation-foundations; for architecture-level record/replay use /determinism-and-replay; for game-feel and sandbox design use /systems-as-experience.

0 installs
▌
Using Distributed Systems · tachyon-beep bundle
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 drifting apart, or "works in staging, melts under load." Architecture-level — how to design correctness under partial failure, not how to deploy it. Single-service API internals → `axiom-web-backend`; CI/CD and ops → `axiom-devops-engineering`; replay/seed determinism → `axiom-determinism-and-replay`; broker/event-sourcing mechanics → the event-driven pack.

0 installs
▌
Using Pytorch Engineering · tachyon-beep bundle
Routes to appropriate PyTorch specialist skill based on symptoms and problem type

0 installs
▌
Using Structure Synthesis · tachyon-beep bundle
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 and latent-conditioned generation, best-of-K pools, mutation/recombination over lineages, canonicalisation to normal forms, graph isomorphism and equivalence detection, semantic hashing, and mode-collapse diagnosis. Use for "graph grammar", "DAG generation", "canonicalise a graph", "graph isomorphism", "semantic hash", "duplicate rate after canonicalisation", "constrained decoding" for structured outputs, or "evolutionary search over graphs". Also use to audit a generator/verifier split for the generator grading its own examination.

0 installs
▌
Using Contract Engineering · tachyon-beep bundle
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 changing meaning, unit, or shape under a slowly-upgrading fleet; when one record is derived from others and must be reproducible; when a consumer must be provably unable to see a field; when decisions must stay interpretable after thresholds are retuned. Pairs with `/determinism-and-replay` (whole-system replay) and `/solution-architect` (which boundaries exist at all). Do not load for REST/GraphQL endpoint design (`/web-backend`) or wire-protocol performance tuning.

0 installs
▌
Using System Archaeologist · tachyon-beep bundle
Use when analyzing existing codebases to generate architecture documentation - coordinates subagent-driven exploration with mandatory workspace structure, validation gates, and pressure-resistant workflows

0 installs
▌
Using Neural Architectures · tachyon-beep bundle
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 (SDXL/FLUX/DiT), multimodal (CLIP/SigLIP/LLaVA), SAM/SAM-2, equivariant GNNs, normalization, attention variants

0 installs
▌
Using Skillpack Maintenance · tachyon-beep bundle
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

0 installs
▌
Using Dynamic Architectures · tachyon-beep bundle
Use when building networks that grow, prune, or adapt topology during training. Routes to continual learning, gradient isolation, modular composition, and lifecycle orchestration skills.

0 installs
▌
Governance And Risk · tachyon-beep bundle
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

0 installs
▌
Using Audit Pipelines · tachyon-beep bundle
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 auditor, regulator, customer, or court might later ask "prove it" about a decision the system made. Use when retention, redaction, or right-to-be-forgotten obligations conflict naively with append-only storage. Do not use for ordinary observability or for system-level threat modelling.

0 installs
▌
Using MCP Engineering · tachyon-beep bundle
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 discipline, and choosing between tools / resources / prompts / sampling. Also use when an MCP server's tools confuse agents, return unstructured errors, deadlock under concurrent calls, double-execute under retry, or lose state across reconnects. Do not use for general REST/GraphQL API design (use `/web-backend`), for client-side prompt engineering or tool-loop design (use `/llm-specialist`), for general in-process plugin architecture (use `/system-architect`), or for cryptographic-provenance audit trails (use `/audit-pipelines`).

0 installs
▌
Using Rust Workspaces · tachyon-beep bundle
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-unification surprises produce different binaries from `cargo build` vs `cargo build -p`, or when deciding which crates to publish vs keep private. Pairs with `/rust-engineering` — that pack is single-crate-shaped; this pack composes those concerns at workspace scale. Do not load for a single-crate project.

0 installs
▌
Platform Integration · tachyon-beep bundle
Use when implementing CMMI processes in GitHub or Azure DevOps, migrating between platforms, or establishing traceability/compliance on GitHub/Azure - platform-specific process guidance

0 installs
▌
Using Creative Writing · tachyon-beep bundle
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.

0 installs
▌
Using Technical Writer · tachyon-beep bundle
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 line) files

0 installs
▌
Using Rust Engineering · tachyon-beep bundle
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

0 installs
▌
Requirements Lifecycle · tachyon-beep bundle
Use when defining requirements, tracking traceability, managing requirement changes, or establishing RTM - covers elicitation, analysis, specification across CMMI Levels 2-4

0 installs
▌
Using System Architect · tachyon-beep bundle
Use when you have architecture documentation from system-archaeologist and need critical assessment, refactoring recommendations, or improvement prioritization - routes to appropriate architect specialist skills

0 installs
▌
Sme Agent Protocol · tachyon-beep
Mandatory protocol for all SME (Subject Matter Expert) agents. Defines fact-finding requirements, output contracts, confidence/risk assessment, and qualification of advice.

0 installs
▌
Using Pyo3 Interop · tachyon-beep bundle
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 GIL contention, segfault on import or exit, NumPy view pointing at freed memory, traceback truncated to one frame, async hang, or a wheel that imports on Mac and crashes on Linux. Pairs with `/rust-engineering` (single-crate Rust) and `/rust-workspaces` (multi-crate Rust). Do not load for pure-Python work or for Rust crates with no Python surface.

0 installs
▌
Reader Panel Review · tachyon-beep
Orchestrate a simulated reader panel review — spawn persona-reader agents as teammates, manage the chapter pump, enforce the Step A gate, and coordinate synthesis

0 installs
▌
Implementation Planning · tachyon-beep
Use when you have specifications or requirements for multi-step implementation tasks requiring comprehensive documentation for handoff

0 installs
▌
Using Site Designer · tachyon-beep bundle
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

0 installs
▌
Design And Build · tachyon-beep bundle
Use when making architecture decisions, setting up CI/CD, managing technical debt, or choosing branching strategies - enforces ADR requirements and prevents resume-driven design

0 installs
▌
Using Wiki Manager · tachyon-beep bundle
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

0 installs
▌
Using Ml Production · tachyon-beep bundle
Router skill directing to deployment, optimization, MLOps, and monitoring guides.

0 installs
▌
Quality Assurance · tachyon-beep bundle
Use when deciding test strategy, struggling with code reviews, shipping without tests, or conflating verification with validation

0 installs
▌
Lifecycle Adoption · tachyon-beep bundle
Use when starting new projects with CMMI, adding CMMI to active development, preparing for audits, migrating tools, or facing team resistance to process adoption

0 installs
▌
Using LLM Specialist · tachyon-beep bundle
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 caching, inference optimization (vLLM / SGLang / TensorRT-LLM), evaluation (incl. LLM-as-judge bias controls and capability suites), or safety (OWASP LLM Top 10, 2025 + 2026 renumbering). Calibrated to 2026-05 with capability-tier vocabulary (frontier-reasoning / frontier-general / fast-cheap / on-device) instead of hardcoded model IDs. Routes to the right specialist sheet.

0 installs
▌
Filigree Workflow · tachyon-beep bundle
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 uses filigree for issue tracking. Provides workflow patterns, team coordination protocols, and operational guidance for the filigree issue tracker.

0 installs
▌
Plan Review · tachyon-beep
Use after implementation-planning to validate plans against codebase reality, risk, complexity, and project conventions before execution

0 installs
▌
Using Deep Rl · tachyon-beep bundle
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 credit assignment. Routes to the matching specialist sheet by problem type and algorithm family.

0 installs
▌
Using UX Designer · tachyon-beep bundle
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.

0 installs
▌
Using Web Backend · tachyon-beep bundle
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

0 installs
▌
Using Game Design · tachyon-beep bundle
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 that combine into a globally boring game; or challenging design assumptions with player behavior and evidence. Covers digital games, board and card games, tabletop roleplaying, LARP and live/embodied play, physical and social games, educational and training games, asynchronous games, and hybrids. Routes to 15 specialist reference sheets. For emergence-forward systemic design use /systems-as-experience; for in-engine simulation implementation use /simulation-tactics; for game UI use /ux-designer.

0 installs
▌
Using Tui Designer · tachyon-beep bundle
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 architecture, responsive layout, flicker-free rendering, keyboard/mouse/focus input, semantic color and theming, affordances and discoverability, feedback and async work, information density, terminal accessibility, signal-safe lifecycle and terminal restoration, testing, and cross-environment distribution. Routes to 13 specialist sheets.

0 installs

56 published skills