constella 0.1.0

package/skills/references/web-animation-codrops/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: web-animation-codrops
+description: Distilled Codrops web-animation and interaction techniques (paraphrased); consult for motion, scroll, and creative front-end effects.
+domain: reference
+category: reference
+tags: [animation, interaction, motion, gsap, webgl, css]
+official_sources:
+  - https://tympanus.net/codrops/
+  - https://tympanus.net/codrops/category/tutorials/
+verified: 2026-06-16
+---
+
+# Web Animation — Codrops Techniques
+
+## Overview
+Codrops (tympanus.net/codrops) is a long-running web-creativity resource publishing tutorials, case studies, and open demos on advanced front-end motion and interaction since 2009. It is an inspiration-and-learning source, not a library you install. Read this skill when a task needs interactive motion — scroll-driven reveals, hover and pointer effects, page transitions, text animations, or WebGL/shader-backed visuals — and you want the recurring techniques distilled rather than copied. Paraphrase its ideas; never paste its code or article text.
+
+## Official sources
+- Site: https://tympanus.net/codrops/
+- Tutorials: https://tympanus.net/codrops/category/tutorials/
+- Demos / Creative Hub: https://tympanus.net/codrops/ (linked from the homepage)
+
+## Core concepts
+- **Animation libraries vs. native.** Codrops techniques typically lean on GSAP (timelines, easing, ScrollTrigger) and the native Web Animations API / CSS transitions for DOM motion, and Three.js / raw WebGL shaders for canvas-based effects. Pick native CSS for simple state transitions and a library for orchestrated sequences.
+- **Scroll-driven interaction.** A core genre: tying animation progress to scroll position (reveals, parallax, pinned sections, horizontal scroll). Modern approaches use the CSS Scroll-Driven Animations spec where supported, or ScrollTrigger / IntersectionObserver otherwise.
+- **Pointer- and hover-reactive effects.** Image distortion on hover, magnetic buttons, cursor followers, and tilt effects driven by pointer coordinates mapped to transforms or shader uniforms.
+- **Page and element transitions.** Smooth route/section transitions (FLIP technique, shared-element morphs, clip-path/mask reveals) that preserve visual continuity instead of hard cuts.
+- **Performance discipline.** Animate compositor-friendly properties (transform, opacity) and avoid layout-thrashing properties (top/left/width/height); offload heavy visuals to GPU via WebGL.
+
+## Best practices
+- Animate `transform` and `opacity` rather than geometric/layout properties so the browser stays on the GPU compositor and avoids reflow.
+- Drive scroll effects with `IntersectionObserver` (or native scroll-driven animations) instead of high-frequency `scroll` listeners to keep the main thread free.
+- Respect `prefers-reduced-motion`: gate non-essential motion behind the media query so the experience degrades gracefully for users who opt out.
+- Use easing and staggering deliberately — entrance reveals read better with slight stagger and natural easing than with uniform linear timing.
+- Lazy-load and conditionally mount WebGL/Three.js scenes so heavy effects never block first paint on slower devices.
+
+## Common pitfalls
+- Animating `width`, `height`, `top`, or `left` causing layout thrash and jank → animate `transform: scale()/translate()` instead.
+- Attaching expensive work to a raw `scroll` event that fires on every frame → debounce/throttle or switch to `IntersectionObserver`/scroll-driven animations.
+- Shipping motion with no `prefers-reduced-motion` fallback → accessibility regression; always provide a reduced or static path.
+- Copying a Codrops demo wholesale (markup, CSS, and JS) into production → respect licensing and rebuild the technique in your own code.
+
+## Examples
+```css
+/* Reveal on scroll, GPU-friendly, with reduced-motion fallback */
+.reveal { opacity: 0; transform: translateY(24px); transition: opacity .6s ease, transform .6s ease; }
+.reveal.is-visible { opacity: 1; transform: none; }
+
+@media (prefers-reduced-motion: reduce) {
+  .reveal { transition: none; opacity: 1; transform: none; }
+}
+```
+```js
+// Toggle the reveal class with IntersectionObserver (not a scroll listener)
+const io = new IntersectionObserver(
+  (entries) => entries.forEach(e => e.isIntersecting && e.target.classList.add('is-visible')),
+  { threshold: 0.2 }
+);
+document.querySelectorAll('.reveal').forEach(el => io.observe(el));
+```
+
+## Further reading
+- Codrops tutorials category for technique walkthroughs (study, then re-implement in your own words).
+- MDN: Web Animations API and CSS scroll-driven animations for the native-platform equivalents.
+
+## Related skills
+- ../react-component-libraries — Magic UI / React Bits package many of these motion patterns as ready components.
+- ../gradient-resources — animated and shader gradients pair with Codrops-style hero effects.

package/skills/stacks/aiml/jupyter/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: jupyter
+description: Jupyter provides interactive computing notebooks (JupyterLab, Jupyter Notebook) that mix live code, equations, visualizations, and narrative text, executed by language-specific kernels over the notebook (.ipynb) format. Consult this when installing/launching JupyterLab or the classic Notebook, working with cells and kernels, choosing the IPython kernel, managing the .ipynb JSON format, using magics (%matplotlib, %timeit), connecting to a server, or troubleshooting kernel selection, reproducibility, and out-of-order execution.
+domain: stack
+category: aiml
+tags: [jupyter, jupyterlab, notebook, ipython, kernel, interactive-computing, python]
+official_sources:
+  - https://docs.jupyter.org/en/latest/
+  - https://github.com/jupyterlab/jupyterlab
+  - https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html
+verified: 2026-06-17
+---
+
+# Jupyter
+
+## Overview
+Project Jupyter provides open-source software for interactive computing across dozens of programming languages, most visibly the web-based JupyterLab IDE and the classic Jupyter Notebook. Notebooks combine executable code cells, rich output, and Markdown narrative in a single `.ipynb` document run by a language kernel. Read this when setting up notebooks, managing kernels, or building reproducible interactive data/ML workflows.
+
+## Official sources
+- Docs: https://docs.jupyter.org/en/latest/
+- Repo: https://github.com/jupyterlab/jupyterlab
+- Install: https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html
+
+## Install / setup
+```bash
+pip install jupyterlab
+jupyter lab
+```
+Commands from the official JupyterLab install guide: https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html
+
+## Core concepts
+- **Notebook (.ipynb)** — JSON document of ordered cells plus outputs and metadata.
+- **Cell** — unit of content; code cells execute, Markdown cells render text/LaTeX.
+- **Kernel** — separate process that runs code (IPython for Python); holds session state.
+- **JupyterLab vs Notebook** — Lab is the modern extensible IDE; Notebook 7 is the lightweight document-centric UI (both on the same server).
+- **Magics** — IPython commands: line (`%timeit`, `%matplotlib`) and cell (`%%bash`, `%%time`).
+- **Kernel state** — variables persist across cells in execution order, independent of cell layout order.
+- **Server** — the Jupyter Server backend that the browser frontend connects to (local or remote).
+
+## Best practices
+- Restart the kernel and "Run All" before sharing to guarantee top-to-bottom reproducibility (https://docs.jupyter.org/en/latest/).
+- Install packages into the same environment the kernel uses (`%pip install`) to avoid kernel/env mismatch (https://docs.jupyter.org/en/latest/install.html).
+- Register environments as named kernels with `ipykernel` so you can pick them in the UI (https://ipython.readthedocs.io/en/stable/install/kernel_install.html).
+- Keep notebooks small and factor reusable logic into imported `.py` modules (https://jupyterlab.readthedocs.io/en/stable/).
+
+## Common pitfalls
+- Out-of-order cell execution creates hidden state → restart kernel and run all to verify.
+- Wrong kernel/env means `import` fails despite a `pip install` in a terminal → install into the kernel's env with `%pip`.
+- Committing notebooks with large outputs bloats diffs → clear outputs (or use nbstripout) before commit.
+
+## Examples
+```bash
+# Create and register a dedicated kernel for a virtual environment
+python -m venv .venv && source .venv/bin/activate
+pip install ipykernel
+python -m ipykernel install --user --name myproject --display-name "Python (myproject)"
+jupyter lab
+```
+
+## Further reading
+- https://docs.jupyter.org/en/latest/ — Project Jupyter documentation hub
+- https://jupyterlab.readthedocs.io/en/stable/ — JupyterLab user guide
+- https://ipython.readthedocs.io/en/stable/interactive/magics.html — IPython magic commands
+
+## Related skills
+- ../pandas — common notebook companion for data analysis
+- ../numpy — numerical computing in notebooks
+- ../scikit-learn — interactive ML experimentation

package/skills/stacks/aiml/keras/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: keras
+description: Keras is a high-level, multi-backend deep learning API (Keras 3) that runs on JAX, TensorFlow, or PyTorch, offering Sequential/Functional/subclassed models with a clean compile/fit/evaluate workflow. Consult this when building neural networks quickly, defining layers and custom models, configuring optimizers/losses/metrics and callbacks, choosing or switching the KERAS_BACKEND, saving/loading .keras models, or porting code across JAX/TF/PyTorch backends.
+domain: stack
+category: aiml
+tags: [keras, deep-learning, neural-networks, tensorflow, jax, pytorch, python]
+official_sources:
+  - https://keras.io/
+  - https://github.com/keras-team/keras
+  - https://keras.io/getting_started/
+verified: 2026-06-17
+---
+
+# Keras
+
+## Overview
+Keras is a deep learning API written in Python, focused on enabling fast experimentation with a clean, layered model-building interface. Keras 3 is multi-backend: the same model code runs on JAX, TensorFlow, or PyTorch, selected via the `KERAS_BACKEND` environment variable. Read this when building/training neural networks at a high level, choosing a backend, or saving and loading models.
+
+## Official sources
+- Docs: https://keras.io/
+- Repo: https://github.com/keras-team/keras
+- Install: https://keras.io/getting_started/
+
+## Install / setup
+```bash
+pip install --upgrade keras
+# then install a backend (one of), e.g.:
+pip install tensorflow   # or: pip install jax  /  pip install torch
+export KERAS_BACKEND="jax"
+```
+Commands from the official getting-started guide: https://keras.io/getting_started/
+
+## Core concepts
+- **Backend** — JAX, TensorFlow, or PyTorch; set `KERAS_BACKEND` (or `~/.keras/keras.json`) before `import keras`; cannot change after import.
+- **Sequential API** — linear stack of layers for simple feed-forward models.
+- **Functional API** — build arbitrary DAGs of layers via tensor calls; the recommended general-purpose API.
+- **Subclassing** — subclass `keras.Model`/`keras.layers.Layer` and implement `call()` for full control.
+- **compile / fit / evaluate / predict** — declare optimizer, loss, and metrics, then train and run inference.
+- **Callbacks** — hooks like `ModelCheckpoint`, `EarlyStopping`, `TensorBoard` during training.
+- **.keras format** — the modern single-file model serialization format (`model.save("m.keras")`).
+
+## Best practices
+- Set `KERAS_BACKEND` before importing Keras; it cannot be switched afterward (https://keras.io/getting_started/).
+- Prefer the Functional API for multi-input/output or branching models over deep subclassing (https://keras.io/guides/functional_api/).
+- Use `EarlyStopping` + `ModelCheckpoint` callbacks rather than fixed epoch counts (https://keras.io/api/callbacks/).
+- Save in the native `.keras` format for full architecture+weights portability (https://keras.io/guides/serialization_and_saving/).
+
+## Common pitfalls
+- Importing Keras before setting `KERAS_BACKEND` → backend locks to the default; set the env var first.
+- Confusing standalone `keras` (Keras 3) with `tf.keras` bundled in TensorFlow → pick one import path consistently.
+- Loading legacy `.h5`/SavedModel into Keras 3 without matching custom objects → register them or re-export to `.keras`.
+
+## Examples
+```python
+import os
+os.environ["KERAS_BACKEND"] = "jax"  # before importing keras
+import keras
+from keras import layers
+
+model = keras.Sequential([
+    layers.Dense(128, activation="relu"),
+    layers.Dense(10, activation="softmax"),
+])
+model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
+# model.fit(x_train, y_train, epochs=3, validation_split=0.1)
+model.save("model.keras")
+```
+
+## Further reading
+- https://keras.io/guides/ — developer guides (Functional API, custom training, serialization)
+- https://keras.io/api/ — full layers/models/callbacks API reference
+- https://keras.io/examples/ — code examples across vision, NLP, and more
+
+## Related skills
+- ../tensorflow — a Keras backend; `tf.keras` ships with TensorFlow
+- ../pytorch — a supported Keras 3 backend
+- ../numpy — array inputs to Keras models

package/skills/stacks/aiml/numpy/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: numpy
+description: NumPy is the foundational Python package for scientific and numerical computing, providing the n-dimensional ndarray plus fast vectorized math, broadcasting, linear algebra, FFT, and random number generation. Consult this when working with arrays and dtypes, vectorizing loops, using broadcasting and slicing/fancy indexing, doing matrix math or reductions along axes, generating random data with the Generator API, or interoperating with pandas, scikit-learn, PyTorch, and TensorFlow.
+domain: stack
+category: aiml
+tags: [numpy, ndarray, scientific-computing, linear-algebra, vectorization, arrays, python]
+official_sources:
+  - https://numpy.org/doc/stable/
+  - https://github.com/numpy/numpy
+  - https://numpy.org/install/
+verified: 2026-06-17
+---
+
+# NumPy
+
+## Overview
+NumPy is the fundamental package for scientific computing with Python, centered on a fast, memory-efficient n-dimensional array object (`ndarray`) and a large library of vectorized mathematical functions. It is the numerical bedrock that pandas, scikit-learn, SciPy, PyTorch, and TensorFlow build on or interoperate with. Read this when manipulating arrays, vectorizing computation, using broadcasting, or doing linear algebra and random sampling.
+
+## Official sources
+- Docs: https://numpy.org/doc/stable/
+- Repo: https://github.com/numpy/numpy
+- Install: https://numpy.org/install/
+
+## Install / setup
+```bash
+pip install numpy
+```
+Command from the official install page: https://numpy.org/install/
+
+## Core concepts
+- **ndarray** — fixed-size, homogeneous n-dimensional array; the core data structure.
+- **dtype** — explicit element type (e.g. `int64`, `float32`) controlling memory and precision.
+- **Broadcasting** — rules that let arrays of different shapes combine elementwise without copies.
+- **Vectorization** — elementwise ufuncs replace Python loops for C-speed computation.
+- **Indexing** — basic slicing (views), plus boolean masks and fancy (integer-array) indexing (copies).
+- **Axes & reductions** — operations like `sum`/`mean`/`max` reduce along a chosen `axis`.
+- **Generator (random)** — modern RNG via `np.random.default_rng()` (preferred over legacy `np.random.*`).
+
+## Best practices
+- Replace Python loops with vectorized ufuncs and broadcasting for speed (https://numpy.org/doc/stable/user/basics.broadcasting.html).
+- Use `np.random.default_rng()` instead of the legacy global random functions (https://numpy.org/doc/stable/reference/random/index.html).
+- Be aware that basic slices return views (mutations propagate); copy with `.copy()` when needed (https://numpy.org/doc/stable/user/basics.copies.html).
+- Pick the smallest sufficient dtype (e.g. `float32`) to cut memory for large arrays (https://numpy.org/doc/stable/reference/arrays.dtypes.html).
+
+## Common pitfalls
+- Mutating a slice view unexpectedly changes the parent array → use `.copy()` for independent data.
+- Integer overflow with fixed-width dtypes wraps silently → cast to a wider dtype before large sums.
+- Comparing floats with `==` fails due to precision → use `np.isclose`/`np.allclose`.
+
+## Examples
+```python
+import numpy as np
+
+rng = np.random.default_rng(0)
+a = rng.standard_normal((1000, 3))          # 1000x3 array
+norms = np.linalg.norm(a, axis=1)           # per-row L2 norm (vectorized)
+unit = a / norms[:, None]                    # broadcasting to normalize rows
+print(unit.shape, np.allclose(np.linalg.norm(unit, axis=1), 1.0))
+```
+
+## Further reading
+- https://numpy.org/doc/stable/user/absolute_beginners.html — beginner's guide
+- https://numpy.org/doc/stable/user/basics.broadcasting.html — broadcasting rules
+- https://numpy.org/doc/stable/reference/ — full API reference
+
+## Related skills
+- ../pandas — built on top of NumPy arrays
+- ../scikit-learn — consumes ndarrays as X/y
+- ../pytorch — tensors convert to/from NumPy

package/skills/stacks/aiml/pandas/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: pandas
+description: pandas is the standard Python library for labeled tabular data analysis and manipulation, providing the DataFrame and Series structures for loading, cleaning, reshaping, grouping, joining, and aggregating data. Consult this when reading/writing CSV/Parquet/Excel/SQL, filtering and selecting rows/columns with loc/iloc, handling missing data, doing groupby aggregations, merging/joining tables, pivoting/melting, working with time series and datetime indexes, or understanding Copy-on-Write (the default in pandas 3.0) and why chained assignment never modifies the original.
+domain: stack
+category: aiml
+tags: [pandas, dataframe, data-analysis, data-wrangling, etl, time-series, python]
+official_sources:
+  - https://pandas.pydata.org/docs/
+  - https://github.com/pandas-dev/pandas
+  - https://pandas.pydata.org/docs/getting_started/install.html
+verified: 2026-06-17
+---
+
+# pandas
+
+## Overview
+pandas is a fast, flexible, and expressive Python library providing labeled data structures (`Series`, `DataFrame`) for working with relational and time-series data. It is the de facto tool for data loading, cleaning, transformation, and exploratory analysis, and feeds most ML and analytics workflows. Read this when wrangling tabular data, doing groupby/merge/pivot operations, or handling missing values and datetime indexes.
+
+## Official sources
+- Docs: https://pandas.pydata.org/docs/
+- Repo: https://github.com/pandas-dev/pandas
+- Install: https://pandas.pydata.org/docs/getting_started/install.html
+
+## Install / setup
+```bash
+pip install pandas
+```
+Command from the official install guide: https://pandas.pydata.org/docs/getting_started/install.html
+
+## Core concepts
+- **DataFrame** — 2D labeled table with heterogeneous typed columns; the central data structure.
+- **Series** — 1D labeled array; a single DataFrame column.
+- **Index** — row/column labels enabling alignment; includes `DatetimeIndex` and `MultiIndex`.
+- **Label vs position selection** — `.loc[]` selects by label, `.iloc[]` by integer position.
+- **groupby** — split-apply-combine for aggregation and transformation over groups.
+- **merge / join / concat** — SQL-style joins and stacking of DataFrames.
+- **reshape** — `pivot`/`pivot_table`, `melt`, `stack`/`unstack` to move between wide and long forms.
+
+## Best practices
+- Assign via `.loc`/`.iloc` (`df.loc[mask, 'col'] = x`) rather than chained indexing (`df[a][b] = x`); under Copy-on-Write (default in pandas 3.0) chained assignment silently does nothing to the original (https://pandas.pydata.org/docs/user_guide/copy_on_write.html).
+- Use vectorized operations and built-in methods instead of `.iterrows()` loops (https://pandas.pydata.org/docs/user_guide/enhancingperf.html).
+- Parse dates explicitly (`pd.to_datetime`, `parse_dates=`) and set a `DatetimeIndex` for time-series work (https://pandas.pydata.org/docs/user_guide/timeseries.html).
+- Prefer columnar formats like Parquet over CSV for large data round-trips (https://pandas.pydata.org/docs/user_guide/io.html).
+
+## Common pitfalls
+- Chained assignment (`df[mask]['col'] = x`) consistently never modifies the original under Copy-on-Write (default in pandas 3.0); no warning is raised (`SettingWithCopyWarning` was removed in 3.0) → use `df.loc[mask, 'col'] = x`.
+- The `inplace=` keyword is being deprecated (PDEP-8) for methods where it is only syntactic sugar for reassignment → prefer reassigning the result. It is retained for value-mutating methods (`fillna`, `replace`, `ffill`, `bfill`, `interpolate`, `where`, `mask`, `clip`), which in pandas 3.0 now return `self` instead of `None`.
+- Mixing label and position with `.ix` (removed) → use `.loc`/`.iloc`.
+
+## Examples
+```python
+import pandas as pd
+
+df = pd.read_csv("sales.csv", parse_dates=["date"])
+df = df.dropna(subset=["amount"])
+monthly = (
+    df.assign(month=df["date"].dt.to_period("M"))
+      .groupby(["month", "region"], as_index=False)["amount"]
+      .sum()
+)
+print(monthly.head())
+```
+
+## Further reading
+- https://pandas.pydata.org/docs/user_guide/index.html — full user guide
+- https://pandas.pydata.org/docs/getting_started/intro_tutorials/index.html — getting-started tutorials
+- https://pandas.pydata.org/docs/reference/index.html — API reference
+
+## Related skills
+- ../numpy — array engine underlying pandas
+- ../scikit-learn — consumes DataFrames for ML
+- ../jupyter — interactive notebooks for data exploration

package/skills/stacks/aiml/pytorch/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: pytorch
+description: PyTorch is an open-source deep learning framework with Pythonic tensors, dynamic (define-by-run) autograd, and strong GPU/CUDA acceleration, widely used for research and production. Consult this when building neural networks with torch.nn, writing training loops with autograd and optimizers, moving tensors between CPU/GPU/MPS devices, loading data with Dataset/DataLoader, compiling with torch.compile, doing distributed/DDP training, or saving/loading state_dict checkpoints, and when debugging device mismatches, gradient/requires_grad issues, or CUDA installs.
+domain: stack
+category: aiml
+tags: [pytorch, deep-learning, machine-learning, autograd, neural-networks, gpu, python]
+official_sources:
+  - https://docs.pytorch.org/docs/stable/index.html
+  - https://github.com/pytorch/pytorch
+  - https://pytorch.org/get-started/locally/
+verified: 2026-06-17
+---
+
+# PyTorch
+
+## Overview
+PyTorch is a Python-first deep learning framework offering GPU-accelerated tensors and a tape-based automatic differentiation system (autograd) with dynamic computation graphs. It is the dominant framework for ML research and is widely deployed in production via TorchScript, `torch.compile`, and ExecuTorch. Read this when defining models, writing custom training loops, managing devices, or building data pipelines.
+
+## Official sources
+- Docs: https://docs.pytorch.org/docs/stable/index.html
+- Repo: https://github.com/pytorch/pytorch
+- Install: https://pytorch.org/get-started/locally/
+
+## Install / setup
+```bash
+# CPU-only (pip). For CUDA/ROCm builds, use the selector to get the right index URL.
+pip install torch torchvision torchaudio
+```
+Command from the official install selector: https://pytorch.org/get-started/locally/
+
+## Core concepts
+- **Tensor** — n-dimensional array with a dtype and `.device`; supports GPU acceleration and NumPy-like ops.
+- **autograd** — tensors with `requires_grad=True` record ops on a dynamic graph; `.backward()` computes gradients.
+- **torch.nn.Module** — base class for models/layers; holds parameters and defines `forward()`.
+- **Optimizer + loss** — `torch.optim` (SGD, Adam) updates parameters from gradients; losses live in `torch.nn`.
+- **Dataset / DataLoader** — abstractions for sampling, batching, shuffling, and parallel data loading.
+- **Device model** — explicitly move tensors/modules with `.to(device)` (`cuda`, `mps`, `cpu`).
+- **torch.compile** — JIT graph capture + kernel fusion for speedups without changing model code.
+
+## Best practices
+- Zero gradients each step (`optimizer.zero_grad()`) before `loss.backward()` (https://docs.pytorch.org/tutorials/beginner/basics/optimization_tutorial.html).
+- Save the `state_dict`, not the whole pickled model, for portable checkpoints (https://docs.pytorch.org/tutorials/beginner/saving_loading_models.html).
+- Wrap eval/inference in `with torch.no_grad():` and call `model.eval()` to disable dropout/batchnorm updates (https://docs.pytorch.org/docs/stable/notes/autograd.html).
+- Use `DataLoader(num_workers=...)` and `pin_memory=True` to overlap loading with compute (https://docs.pytorch.org/docs/stable/data.html).
+
+## Common pitfalls
+- "Expected all tensors on same device" → move both model and inputs with `.to(device)`.
+- Accumulating graphs/memory by appending live tensors to a list → call `.item()` or `.detach()` for logging.
+- Forgetting `model.train()` after `model.eval()` → batchnorm/dropout behave wrong in the next epoch.
+
+## Examples
+```python
+import torch
+from torch import nn
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model = nn.Sequential(nn.Linear(784, 128), nn.ReLU(), nn.Linear(128, 10)).to(device)
+opt = torch.optim.Adam(model.parameters(), lr=1e-3)
+loss_fn = nn.CrossEntropyLoss()
+
+x, y = torch.randn(32, 784, device=device), torch.randint(0, 10, (32,), device=device)
+for _ in range(3):
+    opt.zero_grad()
+    loss = loss_fn(model(x), y)
+    loss.backward()
+    opt.step()
+```
+
+## Further reading
+- https://docs.pytorch.org/tutorials/ — official tutorials and recipes
+- https://docs.pytorch.org/docs/stable/notes/autograd.html — autograd mechanics
+- https://pytorch.org/get-started/locally/ — install selector for CPU/CUDA/ROCm
+
+## Related skills
+- ../tensorflow — alternative deep learning framework
+- ../keras — high-level API that can run on a PyTorch backend (Keras 3)
+- ../numpy — array library PyTorch tensors convert to/from

package/skills/stacks/aiml/scikit-learn/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: scikit-learn
+description: scikit-learn is the standard Python library for classical (non-deep) machine learning, offering consistent fit/predict/transform APIs for classification, regression, clustering, dimensionality reduction, model selection, and preprocessing built on NumPy/SciPy. Consult this when choosing an estimator, building Pipelines and ColumnTransformers, doing cross-validation and GridSearchCV/hyperparameter tuning, computing metrics, encoding/scaling features, or avoiding data leakage in train/test splits.
+domain: stack
+category: aiml
+tags: [scikit-learn, machine-learning, sklearn, classification, regression, clustering, python]
+official_sources:
+  - https://scikit-learn.org/stable/
+  - https://github.com/scikit-learn/scikit-learn
+  - https://scikit-learn.org/stable/install.html
+verified: 2026-06-17
+---
+
+# scikit-learn
+
+## Overview
+scikit-learn is a Python machine learning library built on NumPy, SciPy, and matplotlib, providing simple and efficient tools for predictive data analysis. It implements a huge range of classical algorithms behind a uniform estimator API (`fit`, `predict`, `transform`) plus utilities for preprocessing, model selection, and evaluation. Read this when doing tabular/classical ML, building reproducible Pipelines, or tuning and validating models.
+
+## Official sources
+- Docs: https://scikit-learn.org/stable/
+- Repo: https://github.com/scikit-learn/scikit-learn
+- Install: https://scikit-learn.org/stable/install.html
+
+## Install / setup
+```bash
+pip install -U scikit-learn
+```
+Command from the official install guide: https://scikit-learn.org/stable/install.html
+
+## Core concepts
+- **Estimator** — any object with `.fit(X, y)`; the unifying abstraction across all algorithms.
+- **Transformer** — estimator with `.transform()` (scalers, encoders, vectorizers) for feature engineering.
+- **Predictor** — estimator with `.predict()` (and often `.predict_proba`/`.score`) for inference.
+- **Pipeline** — chains transformers + a final estimator so fit/transform happen in order and only on training folds.
+- **ColumnTransformer** — applies different transformers to different column subsets in one object.
+- **Model selection** — `train_test_split`, `cross_val_score`, `GridSearchCV`/`RandomizedSearchCV` for evaluation and tuning.
+- **Metrics** — `sklearn.metrics` for accuracy, precision/recall, ROC AUC, RMSE, R², etc.
+
+## Best practices
+- Put all preprocessing in a `Pipeline` so cross-validation refits transforms per fold and prevents leakage (https://scikit-learn.org/stable/modules/compose.html).
+- Fit scalers/encoders on training data only; never fit on the full dataset before splitting (https://scikit-learn.org/stable/common_pitfalls.html).
+- Use `GridSearchCV`/`RandomizedSearchCV` with a `cv` strategy rather than manual loops (https://scikit-learn.org/stable/modules/grid_search.html).
+- Set `random_state` for reproducible splits and estimators (https://scikit-learn.org/stable/common_pitfalls.html).
+
+## Common pitfalls
+- Data leakage from scaling/encoding before the split → wrap preprocessing in a Pipeline and fit inside CV.
+- Using accuracy on imbalanced classes → prefer precision/recall, F1, or ROC/PR AUC.
+- Passing pandas columns of mixed dtypes → encode categoricals (e.g. `OneHotEncoder`) via ColumnTransformer first.
+
+## Examples
+```python
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import cross_val_score
+from sklearn.datasets import load_iris
+
+X, y = load_iris(return_X_y=True)
+pipe = Pipeline([
+    ("scale", StandardScaler()),
+    ("clf", LogisticRegression(max_iter=1000)),
+])
+print(cross_val_score(pipe, X, y, cv=5).mean())
+```
+
+## Further reading
+- https://scikit-learn.org/stable/user_guide.html — comprehensive user guide
+- https://scikit-learn.org/stable/auto_examples/index.html — runnable example gallery
+- https://scikit-learn.org/stable/common_pitfalls.html — common pitfalls and recommended practices
+
+## Related skills
+- ../pandas — DataFrames feeding scikit-learn estimators
+- ../numpy — array backbone for X/y inputs
+- ../jupyter — interactive environment for ML experiments

package/skills/stacks/aiml/tensorflow/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: tensorflow
+description: TensorFlow is Google's open-source end-to-end machine learning and deep learning framework for building, training, and deploying models across CPUs, GPUs, and TPUs. Consult this when working with tf.keras models, tf.data input pipelines, tf.function/autograph graph execution, SavedModel export, TensorFlow Serving/Lite/.js deployment, or distributed training (tf.distribute), and when debugging tensor shapes, eager vs graph mode, or GPU/CUDA setup.
+domain: stack
+category: aiml
+tags: [tensorflow, deep-learning, machine-learning, keras, neural-networks, gpu, python]
+official_sources:
+  - https://www.tensorflow.org/learn
+  - https://github.com/tensorflow/tensorflow
+  - https://www.tensorflow.org/install/pip
+verified: 2026-06-17
+---
+
+# TensorFlow
+
+## Overview
+TensorFlow is an end-to-end open-source platform for machine learning, with a comprehensive ecosystem of tools, libraries, and community resources. It centers on tensors flowing through computational graphs and ships the high-level `tf.keras` API for model building plus tooling for production deployment. Read this when building/training deep learning models, optimizing input pipelines, exporting SavedModels, or deploying with TF Serving, Lite, or .js.
+
+## Official sources
+- Docs: https://www.tensorflow.org/learn
+- Repo: https://github.com/tensorflow/tensorflow
+- Install: https://www.tensorflow.org/install/pip
+
+## Install / setup
+```bash
+# CPU-only
+python3 -m pip install tensorflow
+
+# GPU/CUDA (Linux)
+python3 -m pip install 'tensorflow[and-cuda]'
+```
+Commands from the official install guide: https://www.tensorflow.org/install/pip
+
+## Core concepts
+- **Tensor** — immutable n-dimensional array with a dtype and shape; the unit of data that flows through ops.
+- **tf.keras** — the official high-level API for layers, models (`Sequential`, Functional, subclassing), training loops, and metrics.
+- **Eager vs graph execution** — ops run imperatively by default; `@tf.function` traces Python into an optimized graph (AutoGraph) for speed.
+- **tf.data** — composable, performant input pipelines (`map`, `batch`, `shuffle`, `prefetch`) for streaming data into training.
+- **tf.Variable / GradientTape** — variables hold trainable state; `tf.GradientTape` records ops for automatic differentiation.
+- **tf.distribute.Strategy** — abstraction for multi-GPU/multi-host/TPU training (e.g. `MirroredStrategy`).
+- **SavedModel** — language-neutral serialization format for export, serving, and TFLite/TF.js conversion.
+
+## Best practices
+- Use `tf.data` with `.cache()` and `.prefetch(tf.data.AUTOTUNE)` to keep accelerators fed (https://www.tensorflow.org/guide/data_performance).
+- Wrap hot training steps in `@tf.function` rather than running everything eagerly (https://www.tensorflow.org/guide/function).
+- Use `tf.distribute.MirroredStrategy` for multi-GPU instead of manual device placement (https://www.tensorflow.org/guide/distributed_training).
+- Export a SavedModel for serving with `model.export("path")` (or `tf.saved_model.save(model, "path")`); use `model.save("model.keras")` for the native Keras checkpoint format. In Keras 3 (TF 2.16+), `model.save()` requires a `.keras` extension and no longer writes a SavedModel (https://www.tensorflow.org/guide/saved_model).
+
+## Common pitfalls
+- Mixing NumPy ops inside `@tf.function` creates Python side effects that get traced once → use TF ops or `tf.numpy_function`.
+- Forgetting `.prefetch`/`.batch` ordering starves the GPU → batch then prefetch with AUTOTUNE.
+- GPU not detected → verify with `tf.config.list_physical_devices('GPU')` and match CUDA/cuDNN to the install matrix.
+
+## Examples
+```python
+import tensorflow as tf
+
+model = tf.keras.Sequential([
+    tf.keras.layers.Dense(128, activation="relu"),
+    tf.keras.layers.Dense(10),
+])
+model.compile(optimizer="adam",
+              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
+              metrics=["accuracy"])
+
+(x, y), _ = tf.keras.datasets.mnist.load_data()
+ds = tf.data.Dataset.from_tensor_slices((x / 255.0, y)).batch(32).prefetch(tf.data.AUTOTUNE)
+model.fit(ds, epochs=3)
+```
+
+## Further reading
+- https://www.tensorflow.org/tutorials — official tutorials (beginner to advanced)
+- https://www.tensorflow.org/guide — in-depth guides on tf.data, tf.function, distribution
+- https://www.tensorflow.org/api_docs/python/tf — full Python API reference
+
+## Related skills
+- ../keras — high-level model API; tf.keras is TensorFlow's bundled Keras
+- ../pytorch — alternative deep learning framework
+- ../numpy — array foundation TensorFlow interops with