ehadziabdic/wagents

How agentmemory wires into host coding agents via the connect command. Use when installing agentmemory into a specific agent, when asked which agents are supported, or when a connect adapter writes the wrong config path.

How agentmemory is built, the iii engine primitives it runs on, its storage model, ports, and the viewer. Use when reasoning about how memory is stored or retrieved end to end, when extending the system, or when answering how agentmemory works under the hood.

agentmemory configuration, environment variables, ports, and feature flags. Use when enabling a feature, changing ports, setting an API key, configuring auth, or explaining why a feature is off by default.

The agentmemory plugin hooks that capture observations automatically across the agent session lifecycle. Use when explaining how memory gets captured without manual saves, when debugging missing observations, or when tuning what gets recorded.

Map of every agentmemory MCP tool, what each does, and its parameters. Use when choosing which memory tool to call, when a tool name or argument is unclear, or when answering what agentmemory can do via MCP.

The agentmemory HTTP REST API surface, the primary protocol for talking to the memory server. Use when calling agentmemory over HTTP, when MCP is unavailable and you need a fallback, or when integrating a host that does not speak MCP.

Reference for the Claude API / Anthropic SDK — model ids, pricing, params, streaming, tool use, MCP, agents, caching, token counting, model migration. TRIGGER — read BEFORE opening the target file; don't skip because it "looks like a one-liner" — whenever: the prompt names Claude/Anthropic in any form (Claude, Anthropic, Fable, Opus, Sonnet, Haiku, anthropic, @anthropic-ai, claude-*, us.anthropic.*, [1m]); the user asks about an LLM (pricing/model choice/limits/caching) — never answer from memory; OR the task is LLM-shaped with provider unstated (agent/MCP/tool-definition/multi-agent/RAG/LLM-judge/computer-use; generate/summarize/extract/classify/rewrite/converse over NL; debugging refusals/cutoffs/streaming/tool-calls/tokens). SKIP only when another provider is being worked on (overrides all triggers): OpenAI/GPT/Gemini/Llama/Mistral/Cohere/Ollama named in the query; OR grep -rE 'openai|langchain_openai|google.generativeai|genai|mistralai|cohere|ollama' over the project hits (run this grep FIRST if no provider named — don't Read the file).

Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.

Use this skill whenever the user wants to create, read, edit, or manipulate Word documents (.docx files) or Word templates (.dotx files). Triggers include: any mention of 'Word doc', 'word document', '.docx', '.dotx', or requests to produce professional documents with formatting like tables of contents, headings, page numbers, or letterheads. Also use when extracting or reorganizing content from .docx or .dotx files, inserting or replacing images in documents, performing find-and-replace in Word files, working with tracked changes or comments, or converting content into a polished Word document. If the user asks for a 'report', 'memo', 'letter', 'template', or similar deliverable as a Word or .docx file, use this skill. Do NOT use for PDFs, spreadsheets, Google Docs, or general coding tasks unrelated to document generation.

Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).

Use this skill whenever the user wants to do anything with PDF files. This includes reading or extracting text/tables from PDFs, combining or merging multiple PDFs into one, splitting PDFs apart, rotating pages, adding watermarks, creating new PDFs, filling PDF forms, encrypting/decrypting PDFs, extracting images, and OCR on scanned PDFs to make them searchable. If the user mentions a .pdf file or asks to produce one, use this skill.

Use this skill any time a .pptx or .potx file is involved in any way — as input, output, or both. This includes: creating slide decks, pitch decks, or presentations; reading, parsing, or extracting text from any .pptx or .potx file (even if the extracted content will be used elsewhere, like in an email or summary); editing, modifying, or updating existing presentations; combining or splitting slide files; working with templates (.potx), layouts, speaker notes, or comments. Trigger whenever the user mentions "deck," "slides," "presentation," or references a .pptx or .potx filename, regardless of what they plan to do with the content afterward. If a .pptx or .potx file needs to be opened, created, or touched, use this skill.

Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.

Use this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.

Diátaxis Documentation Expert. An expert technical writer specializing in creating high-quality software documentation, guided by the principles and structure of the Diátaxis technical documentation authoring framework.

Generate draw.io diagrams as .drawio files and export to PNG/SVG/PDF with embedded XML

Query official Microsoft documentation to find concepts, tutorials, and code examples across Azure, .NET, Agent Framework, Aspire, VS Code, GitHub, and more. Uses Microsoft Learn MCP as the default, with Context7 and Aspire MCP for content that lives outside learn.microsoft.com.

AI-powered codebase security scanner that reasons about code like a security researcher — tracing data flows, understanding component interactions, and catching vulnerabilities that pattern-matching tools miss. Use this skill when asked to scan code for security vulnerabilities, find bugs, check for SQL injection, XSS, command injection, exposed API keys, hardcoded secrets, insecure dependencies, access control issues, or any request like "is my code secure?", "review for security issues", "audit this codebase", or "check for vulnerabilities". Covers injection flaws, authentication and access control bugs, secrets exposure, weak cryptography, insecure dependencies, and business logic issues across JavaScript, TypeScript, Python, Java, PHP, Go, Ruby, and Rust.

Architecture decision workflow. Use for system design, boundaries, tradeoffs, ADRs, modernization plans.

Curated design references and component ecosystems for high-end web applications. Includes direct guidance and verified links for ThreeUI, Spline 3D, React Bits components, shadcn/ui, and modern styling libraries.

Exclusive authorized offensive security skillset for the wagent-hacker agent only. Full vendored copy of SnailSploit/Claude-Red (78 skills, 22 categories) at a pinned commit. Requires explicit target authorization before any offensive action.

Web app testing baseline. Use for unit, integration, API, E2E, browser testing. Prefers deterministic realistic checks.

Trace a file, function, or line back to the agent session that produced its current commit. Use when the user asks "why is this code here", "what was the agent doing when this changed", "who wrote this", or wants context on a specific location in the codebase.

List recent git commits linked to agent sessions, optionally filtered by branch or repo. Use when the user asks "show agent commits", "what has the agent shipped", "list linked commits", or wants commits with their session context.

Design and implement data ingestion pipelines for ML workflows. Covers batch ingestion from CSV, Parquet, JSON, Avro, databases (PostgreSQL, MySQL, BigQuery), and cloud storage (S3, GCS, Azure Blob), streaming ingestion with Kafka, Kinesis, Pulsar, and Flink, ETL/ELT pipeline design, data lake ingestion (Delta Lake, Iceberg, Hudi), schema evolution, data versioning with DVC and LakeFS, data catalog integration, incremental loading, partitioning, compression, error handling, retry logic, dead letter queues, idempotency, and exactly-once semantics. Use when building or debugging data ingestion pipelines, connecting ML systems to data sources, moving data into a lake or feature pipeline, setting up streaming ingestion, or versioning training data.

Validate data quality for ML pipelines using Great Expectations, Pandera, Pydantic, and Deequ. Covers schema validation, data profiling, data quality checks (completeness, uniqueness, consistency, accuracy, timeliness), data contracts, anomaly detection in datasets, automated data testing in CI/CD, handling schema evolution and breaking changes, data quality dashboards, alerting on validation failures, and integration with orchestrators like Airflow and Prefect. Use when building data quality gates, profiling datasets, enforcing data contracts, or debugging data issues.

Perform a broad infrastructure and DevOps audit as a senior platform engineer, across reliability, security, cost, observability, and operability, then produce a prioritized, evidence-based findings table and self-contained remediation plans for other agents to execute. Strictly read-only — never applies changes. Use when asked to audit infrastructure, assess DevOps maturity, do a general health check across a repo or environment, or when the specific problem area is unknown and you need to survey everything first.

Identify cloud cost optimization opportunities as a senior FinOps/cloud engineer across compute, storage, networking, and managed services, then produce a prioritized, evidence-based findings table and self-contained remediation plans that cut waste without hurting reliability. Strictly read-only — never resizes, deletes, or modifies resources. Use when asked to reduce cloud spend, find waste, right-size infrastructure, or review cost efficiency of IaC or a live account.

Review database operations and schema-change safety as a senior database reliability engineer — migrations, locking and blocking risk, connection pooling, indexing, replication, PITR, and production data-access paths — then produce an evidence-based findings table and self-contained remediation plans. Strictly read-only — never runs a migration, DDL, DML, kill, failover, or any statement that changes data or schema. Use when asked to review a database migration for safety, assess whether a schema change can be deployed with zero downtime, diagnose connection-pool exhaustion or slow queries from config, or review database reliability and operational posture.

Review Dockerfiles, container images, and Compose files as a senior container engineer, then produce a prioritized, evidence-based findings table and self-contained remediation plans covering image size, build speed, security, and correctness. Strictly read-only — inspects and scans only, never builds-and-pushes or edits. Use when asked to review Dockerfiles, container build setups, image layering, or container security and best practices.

Review backup, restore, and disaster-recovery readiness as a senior SRE — whether backups exist, are recoverable, meet the stated RTO/RPO, survive deletion or ransomware, and whether failover has actually been tested — then produce an evidence-based findings table and self-contained remediation plans. Strictly read-only — never triggers a restore, failover, snapshot deletion, or any change. Use when asked about backups, restore testing, RTO/RPO, data-loss risk, multi-region or multi-AZ failover, business continuity, or "what happens if this database/region/account is lost".

Investigate a production incident as a senior SRE and produce a hypothesis-driven, evidence-logged investigation document plus recommended (never auto-applied) mitigations and durable follow-up plans. Strictly read-only — runs diagnostic and read-only commands only, never restarts, scales, rolls back, or changes anything itself. Use when asked to investigate an outage, degradation, error spike, latency regression, failed deploy, or any "why is production broken" question, or to run a blameless post-incident analysis.

Review Kubernetes manifests, Helm charts, Kustomize overlays, and live workloads as a senior Kubernetes engineer, then produce a prioritized, evidence-based findings table and self-contained remediation plans. Strictly read-only — never applies, scales, deletes, or patches anything. Use when asked to review Kubernetes YAML, Helm charts, or cluster workloads for reliability, security, resource management, or best-practice compliance.

Review monitoring, metrics, logging, tracing, dashboards, and alerting as a senior SRE, then produce a prioritized, evidence-based findings table and self-contained remediation plans that close observability gaps and reduce alert noise. Strictly read-only — never edits dashboards, alert rules, or config. Use when asked to review observability posture, assess whether incidents would be detected, evaluate SLOs/alerts, or fix noisy or missing monitoring.

Review CI/CD pipelines (GitHub Actions, GitLab CI, Jenkins, CircleCI, Azure Pipelines, etc.) as a senior release engineer, then produce a prioritized, evidence-based findings table and self-contained remediation plans covering reliability, speed, security, and correctness. Strictly read-only — never triggers, cancels, or edits pipelines. Use when asked to review CI/CD configuration for flakiness, slow builds, insecure secrets handling, missing gates, or supply-chain risk.

Validate production deployment readiness as a senior release manager/SRE by checking whether a service or release meets reliability, security, observability, rollback, and operational bars before it ships, then produce a go/no-go assessment with an evidence-based gap list and self-contained remediation plans for blockers. Strictly read-only — never deploys, promotes, or changes anything. Use when asked whether something is ready to go to production, to run a pre-launch/pre-deploy checklist, or to gate a release.

Write or audit operational runbooks as a senior SRE — one document per failure mode, with detection signal, triage decision tree, verified read-only diagnostics, mitigation with rollback, escalation path, and verification — grounded in the real repo, alerts, and dashboards rather than generic advice. Strictly read-only on systems — it drafts documents under runbooks/ and never executes a mitigation itself. Use when asked to write a runbook or on-call playbook, document a failure mode or recovery procedure, close a "no runbook for this alert" gap, or review existing runbooks for staleness and accuracy.

Review Terraform (or OpenTofu) code and infrastructure design as a senior cloud/IaC engineer, then produce a prioritized, evidence-based findings table and self-contained remediation plans. Strictly read-only — runs plan/validate only, never apply, destroy, or state changes. Use when asked to review Terraform modules, root configurations, state management, or IaC design for correctness, security, cost, and maintainability.

Design and implement feature engineering pipelines for ML models. Covers numerical transformations (scaling, normalization, binning, polynomial), categorical encoding (one-hot, target, ordinal, hashing), text features (TF-IDF, embeddings, tokenization), image features (CNN extraction, augmentation), time-series features (lag, rolling, Fourier), missing value imputation (KNN, MICE), feature selection (mutual info, SHAP, RFE, L1), automated feature engineering (Featuretools, tsfresh), scikit-learn Pipelines, ColumnTransformer, dimensionality reduction (PCA, UMAP), and production feature pipeline best practices.

Set up and manage feature stores for ML systems. Covers Feast, Hopsworks, and Tecton configuration, online and offline store architecture, feature materialization (batch and streaming), point-in-time correct feature retrieval for training, real-time feature serving for inference, feature freshness and staleness management, feature sharing across teams, feature registry and catalog, feature lineage and provenance, feature store monitoring, and migration strategies. Use when building feature infrastructure, sharing features across models, or serving features in production.

Delete specific observations from agentmemory after showing them and getting explicit confirmation. Use when the user says "forget this", "delete memory", "remove that note", or wants to scrub specific data for privacy.

Resume the most recent agent session for the current working directory, leading with any unanswered question. Use when the user says "where were we", "resume", "handoff", "pick up where I left off", or starts a session with no fresh context.

Save a correction or hard-won rule as a confidence-weighted lesson that resurfaces before similar work. Use when the user corrects your approach, says "learn this", "always" or "never do X", or you notice yourself repeating a past mistake.

Build and orchestrate LLM-powered agents. Covers agent architectures (ReAct, Plan-and-Execute, multi-agent), tool use and function calling, LangChain agents, LangGraph workflows, CrewAI multi-agent systems, Autogen, agent memory (short-term, long-term, episodic), agent planning and reasoning, error handling and recovery, agent evaluation and testing, human-in-the-loop patterns, agent observability, production agent deployment, and agent safety guardrails. Use when building LLM agents, implementing tool use, orchestrating multi-agent systems, or deploying agents to production.

Optimize costs for LLM applications. Covers token optimization (prompt compression, caching, context pruning), model routing (expensive vs cheap models), semantic caching, prompt caching, response caching, model selection strategy (GPT-4o vs GPT-4o-mini vs Claude vs open-source), batch API usage, fine-tuned small models vs large models, cost monitoring and budgeting, rate limit management, embedding cost optimization, and ROI analysis for LLM features. Use when reducing LLM API costs, implementing caching, choosing cost-effective models, or building cost-aware LLM architectures.

Prepare and curate training data for LLM fine-tuning and alignment. Covers instruction dataset creation, data quality assessment, synthetic data generation with LLMs, data annotation workflows (Label Studio, Argilla, Prodigy), preference data collection for RLHF/DPO (chosen/rejected pairs), data deduplication and decontamination, data formatting (Alpaca, ShareGPT, chat templates), dataset balancing and filtering, data augmentation for NLP, PII removal from training data, copyright and licensing considerations, and dataset versioning. Use when preparing data for LLM fine-tuning, generating synthetic training data, setting up annotation pipelines, or curating preference datasets.

Deploy and serve large language models efficiently. Covers vLLM, Text Generation Inference (TGI), Ollama, llama.cpp, ONNX Runtime, TensorRT-LLM, model quantization (GPTQ, AWQ, GGUF, INT4/INT8), KV-cache optimization, continuous batching, speculative decoding, PagedAttention, tensor parallelism, pipeline parallelism, API gateway setup, streaming responses, multi-model serving, GPU memory management, auto-scaling for LLMs, Docker/Kubernetes deployment, and cost-performance optimization. Use when deploying LLMs, optimizing inference speed, reducing serving costs, or setting up LLM infrastructure.

Distill knowledge from large teacher LLMs into small student models via sequence-level (response-based) knowledge distillation. Covers teacher selection and licensing checks, generating distillation data with Bedrock serverless teachers (DeepSeek-R1, Claude via converse), reasoning distillation (keeping <think>/chain-of-thought for math/code/puzzle domains, stripping it for simple QA), sampling and temperature choices, batch generation with retry/backoff, cost estimation, data curation (dedup, decontamination, verifiable-reward filtering, LLM-judge filtering), producing TRL-ready JSONL for SFT/QLoRA, and evaluating distillation quality with student-vs-teacher relative gates. Use when creating a small specialized model from a large model's outputs, building R1-style distilled reasoners, or preparing teacher-generated training data.

Evaluate LLM performance comprehensively. Covers automated metrics (BLEU, ROUGE, METEOR, BERTScore, perplexity), LLM-as-judge evaluation, RAGAS for RAG evaluation, human evaluation frameworks, task-specific benchmarks (MMLU, HellaSwag, HumanEval, MT-Bench), safety evaluation (toxicity, bias, hallucination detection), A/B testing for LLMs, evaluation datasets and test suites, regression testing, latency and cost evaluation, multi-turn conversation evaluation, and building custom evaluation pipelines. Use when evaluating LLM quality, comparing models, testing for safety issues, or building evaluation infrastructure.

Fine-tune large language models with parameter-efficient methods. Covers full fine-tuning, LoRA, QLoRA, PEFT, adapter-based tuning, prefix tuning, prompt tuning, instruction tuning, RLHF (PPO, DPO), SFT (supervised fine-tuning), HuggingFace TRL and PEFT libraries, Unsloth, Axolotl, dataset preparation (Alpaca, ShareGPT, chat formats), training data quality, evaluation during fine-tuning, hyperparameter selection, memory optimization, multi-GPU fine-tuning, merging adapters, and deploying fine-tuned models. Use when fine-tuning LLMs, creating custom models, or implementing RLHF/DPO alignment.

Implement safety guardrails for LLM applications. Covers input validation and content filtering, output validation and safety checks, NeMo Guardrails, Guardrails AI, LLM Guard, toxicity detection, PII detection and redaction, hallucination detection and mitigation, jailbreak prevention, topic restriction, output format enforcement, rate limiting, content moderation pipelines, red teaming, safety benchmarks, and compliance requirements. Use when adding safety measures to LLM apps, preventing harmful outputs, detecting PII, or building content moderation systems.

Monitor and observe LLM applications in production. Covers token usage tracking and cost monitoring, latency monitoring (TTFT, TPS, E2E), LangSmith tracing, LangFuse integration, Phoenix/Arize for LLM observability, prompt/completion logging, conversation tracking, quality metrics over time, error rate monitoring, rate limit tracking, model comparison dashboards, feedback collection, A/B test analysis, hallucination rate monitoring, and LLM-specific alerting. Use when monitoring LLM applications, tracking costs, debugging quality issues, or setting up LLM observability infrastructure.

Design, manage, and version prompts for LLM applications. Covers prompt design patterns (zero-shot, few-shot, chain-of-thought, ReAct, tree-of-thought), system prompt engineering, prompt templates with variables, prompt versioning and A/B testing, prompt management platforms (LangSmith, PromptLayer, Helicone), structured output (JSON mode, function calling, Pydantic), prompt injection defense, prompt optimization and compression, multi-turn conversation design, and prompt evaluation. Use when designing prompts, managing prompt versions, optimizing prompt performance, or defending against prompt injection.

Build and optimize Retrieval-Augmented Generation (RAG) pipelines. Covers document loading and parsing, chunking strategies (fixed-size, semantic, recursive, sentence-based), embedding models (OpenAI, Sentence Transformers, Cohere), vector stores (Chroma, Pinecone, Weaviate, Qdrant, pgvector, FAISS), hybrid search (dense + sparse, BM25 + embeddings), reranking (Cohere, cross-encoders), query transformation, multi-step retrieval, agentic RAG, evaluation (RAGAS), context window optimization, metadata filtering, multi-modal RAG, and production RAG architecture. Use when building RAG systems, improving retrieval quality, or deploying knowledge-augmented LLM applications.

Local-first codebase knowledge graph powered by tree-sitter (158+ languages) and codebase-memory-mcp. Use to index, search, and navigate code topology, symbol dependencies, and call graphs without wasting context tokens.

Safely retrieve, synthesize, and update durable knowledge from your Second Brain in Obsidian vaults or Notion workspaces. Use when the user asks to recall notes, reference second brain knowledge, or record project decisions.

Build and use a shared structural map of the current codebase through codebase-memory-mcp. Use before multi-agent work, architecture exploration, or a repeated codebase question when the MCP is installed.

The session loop that makes agentmemory pay off, recall before starting work, save at decision points, learn from corrections. Use when starting a nontrivial task, after settling a decision or debugging a gotcha, or whenever deciding if something belongs in memory.

CI/CD for machine learning models: from git push to production. Covers model CI (train-on-PR with data slices, quality gates), promotion across dev/staging/prod with GitOps and approval gates, container builds for model images, complete GitHub Actions workflows, SageMaker Pipelines (SDK v3) as managed CD, EventBridge triggers on model approval, and rollback strategy. Use when setting up CI/CD for ML models, automating training pipelines on git events, promoting models dev->staging->prod, building GitHub Actions/GitLab CI for ML, SageMaker Pipelines, or automating deployment on model approval.

Optimize and estimate ML infrastructure costs. Covers GPU selection and pricing (T4 through H200), training cost estimation and reduction, inference cost optimization, spot instance strategies, model compression (quantization, pruning, knowledge distillation), mixed precision, gradient accumulation, resource right-sizing, auto-scaling, scale-to-zero, batch inference, ONNX Runtime, storage tiering, cost tracking, FinOps for ML, LLM API cost sizing, and cloud vs on-prem comparison. Use when estimating or reducing ML costs, choosing a GPU or instance type, sizing a training/inference/LLM workload budget, analyzing experiment spend, or answering "how much will this model cost to train or serve".

Track and manage ML experiments with MLflow, Weights & Biases, Neptune, and CometML. Covers experiment logging (hyperparameters, metrics, artifacts), auto-logging for PyTorch, TensorFlow, scikit-learn, and XGBoost, experiment comparison and visualization, artifact versioning, model lineage, reproducibility (environment, code, data versioning), remote tracking server setup, team collaboration, experiment search and querying, and integration with training pipelines. Use when running experiments, comparing model versions, or setting up experiment infrastructure.

Automate end-to-end ML workflows with Apache Airflow DAGs, Kubeflow Pipelines, Prefect flows, Dagster ops and assets, ZenML, and Argo Workflows. Covers pipeline scheduling (cron, event-driven, data-driven triggers), task dependency management, fan-out/fan-in patterns, parameter passing via XComs and artifacts, retry and error handling, pipeline monitoring and alerting, conditional branching, caching, artifact reuse, pipeline versioning, reproducibility, and CI/CD integration. Use when building or scheduling ML pipelines, wiring training/evaluation/ deployment steps into a DAG, choosing or migrating between orchestrators, or debugging pipeline failures and retries.

Secure ML systems and meet compliance requirements. Covers adversarial attacks and robustness testing, data poisoning detection, model extraction and inversion defense, differential privacy (Opacus, TensorFlow Privacy), federated learning security, model encryption, signing and verification, supply chain security for ML artifacts, input validation for ML APIs, audit logging, PII detection, data anonymization, OWASP ML Top 10, MITRE ATLAS, secret management, secure serving with TLS and authentication, rate limiting, dependency scanning, and fairness auditing. Use when securing models or ML pipelines, scanning artifacts, detecting or anonymizing PII, threat-modeling an ML system, or handling compliance and privacy requirements such as GDPR, CCPA, HIPAA, DPIA, data residency, or audit obligations.

Turn customer requirements into an ML solution architecture. Covers requirements intake (business goals, data reality, SLOs, budget, team skills, compliance), decision frameworks (batch vs real-time vs streaming inference, managed SageMaker/Bedrock vs self-hosted K8s/vLLM, build vs buy, classical ML vs LLM vs hybrid), reference architectures, cost estimation, and engagement deliverables. Use when starting a customer engagement, gathering ML requirements, choosing an architecture, writing a solution proposal, deciding batch vs real-time, SageMaker vs self-hosted, or scoping an MLOps/LLMOps delivery.

Test ML models, data pipelines, and features comprehensively. Covers ML testing pyramid (data, feature, model, integration, system tests), model unit tests (prediction shape, output range, determinism), quality gate tests (accuracy thresholds, performance benchmarks), behavioral testing (invariance, directional, minimum functionality), metamorphic testing, regression testing, smoke tests, shadow testing, A/B testing, load testing, data pipeline testing, property-based testing with Hypothesis, pytest fixtures, synthetic data generation, CI/CD integration, and test coverage for ML code. Use when writing tests for ML systems or setting up quality gates.

Detect and handle data drift, concept drift, and model degradation. Covers statistical drift detection methods (PSI, KS test, chi-squared, Wasserstein distance, KL divergence, Jensen-Shannon divergence), sequential methods (Page-Hinkley, ADWIN, DDM, CUSUM), multivariate drift (MMD, domain classifier), Evidently drift reports, Alibi Detect, NannyML, feature-level vs dataset-level drift, reference window strategies, drift for different data types (numerical, categorical, text, image), automated retraining triggers, drift severity assessment, false positive management, and drift root cause analysis. Use when detecting distribution shifts, setting up drift monitoring, or configuring retraining triggers.

Monitor ML model performance in production. Covers Evidently AI reports and tests, Whylogs profiling, NannyML performance estimation, prediction distribution monitoring, ground truth collection, feature importance tracking, latency and throughput monitoring, error rate tracking, custom business metrics, alerting rules and thresholds (static, dynamic, adaptive), Grafana dashboards, Prometheus metrics, prediction logging, batch vs real-time monitoring, SLA compliance, and monitoring infrastructure. Use when setting up production model monitoring, creating alerts, building dashboards, or debugging model performance degradation.

Implement ML observability for production systems. Covers prediction logging, model explainability (SHAP, LIME, Integrated Gradients, Anchors, counterfactuals), feature attribution, OpenTelemetry integration for ML services, distributed tracing across pipeline components, structured logging, debugging mispredictions, slice-based analysis by cohort/segment, fairness and bias detection, model interpretability dashboards, root cause analysis, data lineage visualization, prediction audit trails, Arize/Fiddler/WhyLabs integration, and custom observability metrics. Use when debugging models, explaining predictions, setting up tracing, or building interpretability dashboards.

Manage ML model lifecycle with model registries. Covers MLflow Model Registry, model versioning (semantic, hash), model artifact storage, model metadata and tagging, model lifecycle stages (staging, production, archived), model promotion workflows, model lineage tracking (data to predictions), model packaging formats (ONNX, TorchScript, SavedModel, joblib), model signatures and schemas, model governance and approval, model comparison, rollback strategies, CI/CD integration for deployment, and model cards. Use when registering, versioning, promoting, or managing model artifacts.

Deploy and serve ML models in production. Covers REST API serving (FastAPI, Flask), gRPC, BentoML, NVIDIA Triton, TorchServe, TF Serving, Seldon Core, KServe on Kubernetes, batch inference (Spark, Ray, Dask), model optimization for serving (ONNX Runtime, TensorRT, quantization, pruning), A/B testing, canary and blue-green deployments, shadow deployments, request batching, auto-scaling, containerization with Docker, health checks, input validation, Prometheus metrics, caching, multi-model serving, and model ensembles. Use when deploying models, building inference APIs, or optimizing serving performance.

Design and run ML model training pipelines with PyTorch, TensorFlow, scikit-learn, XGBoost, LightGBM, and HuggingFace. Covers hyperparameter tuning (Optuna, Ray Tune, Bayesian optimization), distributed training (DDP, DeepSpeed, FSDP, Horovod), mixed precision training (AMP, bf16), learning rate scheduling, early stopping, checkpointing, cross-validation, GPU memory optimization (gradient accumulation, gradient checkpointing), reproducibility, and config-driven training pipeline design. Use when training models, tuning hyperparameters, setting up distributed training, or optimizing training performance.

Create and edit Obsidian Bases (.base files) with views, filters, formulas, and summaries. Use when working with .base files, creating database-like views of notes, or when the user mentions Bases, table views, card views, filters, or formulas in Obsidian.

Interact with Obsidian vaults using the Obsidian CLI to read, create, search, and manage notes, tasks, properties, and more. Also supports plugin and theme development with commands to reload plugins, run JavaScript, capture errors, take screenshots, and inspect the DOM. Use when the user asks to interact with their Obsidian vault, manage notes, search vault content, perform vault operations from the command line, or develop and debug Obsidian plugins and themes.

Extract clean Markdown from HTML pages with Defuddle CLI.

Create and edit JSON Canvas files (.canvas) with nodes, edges, groups, and connections. Use when working with .canvas files, creating visual canvases, mind maps, flowcharts, or when the user mentions Canvas files in Obsidian.

Render Markdown from templates and structured data using Knap CLI. Use when the user asks to apply a Knap template, turn JSON or CSV data into notes, batch-generate Markdown files, or format Defuddle output into a note.

Create and edit Obsidian Flavored Markdown with wikilinks, embeds, callouts, properties, and other Obsidian-specific syntax. Use when working with .md files in Obsidian, or when the user mentions wikilinks, callouts, frontmatter, tags, embeds, or Obsidian notes.

Search agentmemory for past observations, sessions, and learnings about a topic using hybrid BM25 plus vector plus graph search. Use when the user says "recall", "what did we do about", "did we ever", "have we seen", or needs context from past sessions.

Summarize the last N agent sessions for the current project, grouped by date, with highlight observations per session. Use when the user asks "recap", "what have we been doing", "today", "this week", or wants a rollup of recent work.

Save an insight, decision, or learning to agentmemory's long-term storage with searchable concept tags. Use when the user says "remember this", "save this", "note that", "don't forget", or wants to preserve knowledge for future sessions.

Show what happened in recent past sessions on this project as a clean timeline. Use when the user asks "what did we do last time", "session history", "past sessions", or wants an overview of previous work.

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

Use when you have a written implementation plan to execute in a separate session with review checkpoints

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

Use when executing implementation plans with independent tasks in the current session

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

Use when implementing any feature or bugfix, before writing implementation code

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback

Use when starting any conversation - establishes how to find and use skills, requiring skill invocation before ANY response including clarifying questions

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always

Use when you have a spec or requirements for a multi-step task, before touching code

Use when creating new skills, editing existing skills, or verifying skills work before deployment

Premium brand-kit image generation skill for creating high-end brand-guidelines boards, logo systems, identity decks, and visual-world presentations. Trained for minimalist, cinematic, editorial, dark-tech, luxury, cultural, security, gaming, developer-tool, and consumer-app brand systems. Optimized for intentional logo concepting, refined composition, sparse typography, strong symbolic meaning, premium mockups, art-directed imagery, and flexible grid layouts.

Raw mechanical interfaces fusing Swiss typographic print with military terminal aesthetics. Rigid grids, extreme type scale contrast, utilitarian color, analog degradation effects. For data-heavy dashboards, portfolios, or editorial sites that need to feel like declassified blueprints.

Elite UX/UI & Advanced GSAP Motion Engineer. Enforces Python-driven true randomization for layout variance, strict AIDA page structure, wide editorial typography (bans 6-line wraps), gapless bento grids, strict GSAP ScrollTriggers (pinning, stacking, scrubbing), inline micro-images, and massive section spacing.

Elite website image-to-code skill for Codex. For visually important web tasks, it must first generate the design image(s) itself, deeply analyze them, then implement the website to match them as closely as possible. In Codex, it must prefer large, readable, section-specific images instead of tiny compressed boards, generate fresh standalone images for sections or detail views instead of cropping old ones, avoid lazy under-generation, avoid cards-inside-cards-inside-cards UI, and keep the hero clean, spacious, readable, and visible on a small laptop.

Elite mobile app image-generation skill for creating premium, app-native screen concepts and flows. Designed for iOS, Android, and cross-platform mobile products. Prioritizes clean hierarchy, comfortably readable text, strong multi-screen consistency, controlled color palettes, non-generic creative direction, textured surfaces, image-led composition, tasteful custom iconography, and clean phone mockup framing. By default, screens should be shown inside a subtle premium iPhone or similar phone mockup with a visible frame, while the main focus stays on the app content itself. This skill generates images only. It does not write code.

Elite frontend image-direction skill for generating premium, conversion-aware website design references. CRITICAL OUTPUT RULE — generate ONE separate horizontal image FOR EVERY section. A landing page with 8 sections produces 8 images. Never compress multiple sections into one image. Enforces composition variety (not always left-text / right-image), background-image freedom, varied CTAs, varied hero scales (giant / mid / mini minimalist), narrative concept spine, second-read moments, and a single consistent palette across all images. Optimized for landing pages, marketing sites, and product comps that developers or coding models can accurately recreate.

Clean editorial-style interfaces. Warm monochrome palette, typographic contrast, flat bento grids, muted pastels. No gradients, no heavy shadows.

Overrides default LLM truncation behavior. Enforces complete code generation, bans placeholder patterns, and handles token-limit splits cleanly. Apply to any task requiring exhaustive, unabridged output.

Upgrades existing websites and apps to premium quality. Audits current design, identifies generic AI patterns, and applies high-end design standards without breaking functionality. Works with any CSS framework or vanilla CSS.

Anti-slop frontend skill for landing pages, portfolios, and redesigns. The agent reads the brief, infers the right design direction, and ships interfaces that do not look templated. Real design systems when applicable, audit-first on redesigns, strict pre-flight check.

Teaches the AI to design like a high-end agency. Defines the exact fonts, spacing, shadows, card structures, and animations that make a website feel expensive. Blocks all the common defaults that make AI designs look cheap or generic.

Semantic Design System Skill for Google Stitch. Generates agent-friendly DESIGN.md files that enforce premium, anti-generic UI standards — strict typography, calibrated color, asymmetric layouts, perpetual micro-motion, and hardware-accelerated performance.

Design banners for social media, ads, website heroes, creative assets, and print. Multiple art direction options with optional generated or supplied visuals. Actions: design, create, generate banner. Platforms: Facebook, Twitter/X, LinkedIn, YouTube, Instagram, Google Display, website hero, print. Styles: minimalist, gradient, bold typography, photo-based, illustrated, geometric, retro, glassmorphism, 3D, neon, duotone, editorial, collage.

Brand voice, visual identity, messaging frameworks, asset management, brand consistency. Activate for branded content, tone of voice, marketing assets, brand compliance, style guides.

Comprehensive design skill: brand identity, design tokens, UI styling, logo generation (55 styles, Gemini, Atlas Cloud, or MuAPI AI), corporate identity program (50 deliverables, CIP mockups), HTML presentations (Chart.js), banner design (22 styles, social/ads/web/print), icon design (15 styles, SVG, Gemini 3.1 Pro), social photos (HTML→screenshot, multi-platform). Actions: design logo, create CIP, generate mockups, build slides, design banner, generate icon, create social photos, social media images, brand identity, design system. Platforms: Facebook, Twitter, LinkedIn, YouTube, Instagram, Pinterest, TikTok, Threads, Google Ads.

Token architecture, component specifications, and slide generation. Three-layer tokens (primitive→semantic→component), CSS variables, spacing/typography scales, component specs, strategic slide creation. Use for design tokens, systematic design, brand-compliant presentations.

UI/UX design intelligence for web, mobile, and desktop. This skill should be used when designing, building, reviewing, or fixing interfaces, including pages, components, design systems, accessibility, interaction, responsive layout, typography, color, charts, and stack-specific UI implementation. Searchable local data: 79 searchable styles (50 active), 192 product palettes and reasoning profiles, 74 font pairings, 119 UX guidelines, 105 icons, 17 GSAP presets, 25 chart types, and 22 stacks.

Create strategic HTML presentations with Chart.js, design tokens, responsive layouts, copywriting formulas, and contextual slide strategies.

Create beautiful, accessible user interfaces with shadcn/ui components (built on Radix UI + Tailwind), Tailwind CSS utility-first styling, and canvas-based visual designs. Use when building user interfaces, implementing design systems, creating responsive layouts, adding accessible components (dialogs, dropdowns, forms, tables), customizing themes and colors, implementing dark mode, generating visual designs and posters, or establishing consistent styling patterns across applications.

The house format and rules for writing or updating an agentmemory skill. Use when adding a new skill, restructuring an existing one, or reviewing a skill contribution for consistency.