Using AI Engineering

Using AI Engineering

Overview

This meta-skill routes you to the right AI/ML engineering pack based on your task. Load this skill when you need ML/AI expertise but aren't sure which specific pack to use.

Core Principle: Problem type determines routing - clarify before guessing.

When to Use

Load this skill when:

• Starting any AI/ML engineering task
• User mentions: "neural network", "train a model", "RL agent", "fine-tune LLM", "deploy model"
• You recognize ML/AI work but unsure which pack applies
• Need to combine multiple domains (e.g., train RL + deploy)

How to Access Reference Sheets

IMPORTANT: All reference sheets are located in the SAME DIRECTORY as this SKILL.md file.

When this skill is loaded from: skills/using-ai-engineering/SKILL.md

Reference sheets are at: skills/using-ai-engineering/routing-examples.md

NOT at: skills/routing-examples.md ← WRONG PATH

STOP - Mandatory Clarification Triggers

Before routing, if query contains ANY of these ambiguous patterns, ASK ONE clarifying question:

If you catch yourself about to guess the domain, STOP and clarify.

Routing by Problem Type

Cross-Cutting Scenarios

When task spans domains, route to ALL relevant packs in execution order:

Principle: Load in order of dependency. Fix foundation before domain. Complete training before deployment.

Common Routing Mistakes

Pressure Resistance - Critical Discipline

Time/Emergency Pressure

Emergency Protocol:

1. Acknowledge urgency
2. Fast clarification (30 sec)
3. Route to correct pack
4. Let pack provide emergency-appropriate approach

Authority/Hierarchy Pressure

Authority Protocol: "I see [authority] suggested X - to apply it correctly, let me verify problem type"

Sunk Cost Pressure

Sunk Cost Protocol: "I see N hours invested - redirecting now prevents more wasted hours"

Keyword/Anchoring Pressure

Red Flags Checklist - STOP Immediately

Basic Routing Red Flags

• ❌ "I'll guess this domain" → ASK clarifying question
• ❌ "They probably mean X" → Verify, don't assume
• ❌ "Just give generic advice" → Route to specific pack

Time/Emergency Red Flags

• ❌ "Emergency means skip clarification" → Fast clarification IS emergency protocol
• ❌ "Production issue means guess quickly" → Wrong guess = longer outage
• ❌ "I'll skip asking to save time" → Clarifying (30 sec) faster than wrong route (5+ min)

Authority/Social Red Flags

• ❌ "Authority figure suggested X, so route to X" → Verify task requirements
• ❌ "PM/senior has more context, trust them" → Route based on problem type
• ❌ "They're frustrated/exhausted, avoid redirect" → Continuing wrong path makes it worse

Sunk Cost Red Flags

• ❌ "They invested N hours in X, continue there" → Sunk cost fallacy, cut losses
• ❌ "Redirecting invalidates their effort" → Correct routing enables success
• ❌ "Too much sunk cost to change direction" → More investment = more waste

Keyword/Anchoring Red Flags

• ❌ "They mentioned transformer/CNN, discuss architecture" → Check problem type first
• ❌ "LLM/RL mentioned, route to that domain" → Could be foundation issue
• ❌ "Technical jargon means they know domain" → Vocabulary ≠ correct self-diagnosis

All of these mean: Either ASK ONE clarifying question, or reconsider your routing logic.

Comprehensive Rationalization Prevention Table

When NOT to Use Yzmir Skills

Skip AI/ML skills when:

• Simple data processing without ML.
• Statistical analysis unconnected to an ML experiment (business reporting, survey analysis, classical inference on non-model data).
• Data cleaning / ETL without model training.
• The task is pure system architecture (route to axiom-solution-architect), pure DevOps (route to axiom-devops-engineering), or pure security threat modeling for the surrounding system (route to ordis-security-architect).

Edge cases worth naming:

• "Build a chatbot" with no ML training and no fine-tuning — usually a Yzmir question (llm-specialist: prompting, RAG, agent loop) but bring in axiom-solution-architect if the request is really about system design.
• "Why does my agent's tool call fail?" — usually llm-specialist (agentic patterns), but if it's a tool-runtime / sandbox / IPC issue it's axiom-engineering-foundations.
• "Make my LLM responses cheaper" — llm-specialist (prompt caching, model routing, smaller models) and/or ml-production (serving stack). Both are valid.
• "Is this result statistically significant?" — stays inside Yzmir whenever the thing measured is an ML experiment: paired branch comparisons, seed counts and power, grouped splits and leakage, best-of-K selection bias, abstention calibration → counterfactual-statistics. Only leave Yzmir if the data has nothing to do with a model.

Red flag: If you're not training, deploying, prompting, retrieving for, evaluating, generating structures for, or designing/analysing an experiment on a model, you probably don't need Yzmir.

Routing Summary Flowchart

User Query
    ↓
Is query ambiguous? → YES → ASK clarifying question
    ↓ NO
Identify problem type:
    - Framework error / PyTorch API? → pytorch-engineering
    - Training not working / optimizer / precision? → training-optimization
    - RL problem? → deep-rl
    - LLM application (prompt, RAG, fine-tune, reasoning, agent, MCP)? → llm-specialist
    - Architecture choice (CNN/transformer/Mamba/diffusion)? → neural-architectures
    - Production deployment / serving / observability? → ml-production
    - Network grows/prunes / continual learning / PEFT (LoRA/QLoRA/DoRA/...) / MoE composition? → dynamic-architectures
    - RL controller deciding WHEN/HOW to grow a network (governor, safety gates, rollback)? → morphogenetic-rl
    - Simulation math / determinism / ODEs? → simulation-foundations
    - Is the measured difference real? paired branches / seed count / leakage / best-of-K / calibration? → counterfactual-statistics
    - Generator emits graphs? typed DAG grammar / NAS search space / canonicalisation / semantic hashing? → structure-synthesis
    - Whole-system feedback / causal loops / leverage? → systems-thinking
    ↓
Cross-cutting? → YES → Route to MULTIPLE packs (order by dependency)
    ↓ NO
Route to single pack

Examples

See routing-examples.md for detailed worked examples:

• Ambiguous queries
• Cross-cutting scenarios
• Misleading keywords
• Time pressure handling
• Foundation issues disguised as domain issues
• Emergency + authority pressure
• Sunk cost + frustration
• Multiple pressures combined

AI Engineering Plugin Router Catalog

This meta-router directs you to the appropriate Yzmir AI/ML plugin. The Yzmir faction ships 12 specialist packs plus this router:

1. yzmir-pytorch-engineering — PyTorch framework: CUDA, memory, FSDP/torch.compile, distributed, tensor operations.
2. yzmir-training-optimization — Training problems: optimizers, schedules, precision (BF16/FP8), gradients, convergence, hyperparameters.
3. yzmir-deep-rl — Reinforcement learning: agents, policies, rewards, environments, MDP, offline RL, MARL.
4. yzmir-llm-specialist — LLM applications: prompting, RAG, fine-tuning (SFT/DPO/GRPO), reasoning models, agentic patterns / MCP, multimodal use, prompt caching, evaluation, safety.
5. yzmir-neural-architectures — Architecture selection: CNN / transformer / Mamba / GNN / diffusion / DiT / multimodal fusion, capacity and depth-width tradeoffs.
6. yzmir-ml-production — Production: vLLM / SGLang / TensorRT-LLM serving, quantization (torchao — the successor to the deprecated torch.ao.quantization — AWQ, GPTQ, FP8), MLOps, observability (Phoenix / Langfuse / OTel GenAI), drift, scaling.
7. yzmir-dynamic-architectures — Networks that grow / prune / adapt: continual learning, gradient isolation, modular composition, MoE routing, adapter merging, PEFT (LoRA / QLoRA / DoRA / VeRA / PiSSA / LoftQ / LoRA+ / rsLoRA / LongLoRA), lifecycle. Owns the HOW: how the growable / adaptable network trains.
8. yzmir-morphogenetic-rl — RL controllers that decide WHEN and HOW to mutate a network's topology during training: action/observation/reward design for the controller, governor and safety gates, rollback-as-RL-signal, deterministic morphogenesis, growth-aware ablation. Companion to dynamic-architectures: owns the CONTROLLER that drives growth, not the network being grown.
9. yzmir-simulation-foundations — Simulation mathematics: ODEs, integrators, stability, control theory, determinism — often the foundation under RL environments and physics-based systems.
10. yzmir-systems-thinking — Systems thinking methodology: causal loops, leverage points, archetypes, stocks-flows, behavior-over-time graphs.
11. yzmir-counterfactual-statistics — Statistics for counterfactual / paired-branch ML experiments: 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 and the leakage taxonomy, best-of-K selection bias / winner's curse, abstention calibration, paired power analysis, pre-registration, and quality-cost-stability frontier reporting. Owns whether a measured difference is real — the pack every other Yzmir pack's "did it help?" question ends up in.
12. yzmir-structure-synthesis — Generative models whose output is a graph: typed DAG grammars with node/edge/cost ceilings, deterministic and latent-conditioned generation, best-of-K pools, mutation and recombination over lineages, canonicalisation to normal forms, equivalence detection and semantic hashing, mode-collapse diagnosis, and generator / structural-verifier / utility-judge separation. Applies to neural architecture search, program synthesis over typed IRs, and molecule / circuit generation. Owns producing a novel candidate structure; neural-architectures owns choosing among human-authored families, dynamic-architectures owns embodying the chosen structure, and counterfactual-statistics owns judging whether it helped.

Adjacent (non-Yzmir) routers worth knowing about:

• axiom-engineering-foundations — general software-engineering rigor for AI systems (debugging, refactoring, code review).
• axiom-solution-architect — when AI is one component of a larger system that needs an architecture document.
• ordis-security-architect — LLM threat modeling, prompt injection, exfil, AI supply chain.
• axiom-python-engineering — Python tooling foundations underneath PyTorch / Transformers code.
• axiom-determinism-and-replay — when the determinism/replay question is about the system (seeds, snapshots, divergence localisation, replay harnesses) rather than the simulation mathematics that simulation-foundations covers.

Remember: When in doubt, ASK. Clarification takes seconds, wrong routing takes minutes. Knowledge cutoff awareness: model IDs and provider features evolve quickly — capability-tier framing in downstream packs (frontier reasoning / frontier general / fast-cheap / on-device) is intentional. Check provider docs for current model IDs before quoting them in user-facing answers.