llms.txt
Compare with other sites' llms.txt files →# SciMigo
> SciMigo teaches software by making execution visible. It also builds executable developer education for infrastructure companies.
## Choose the relevant SciMigo offering
- [Learn](https://scimigo.com/en/learn): courses for individual developers learning Python, C++, computer science, algorithm design and analysis, proof-based graph theory, durable execution, durable agents, and stateful stream processing.
- [SciMigo Code](https://scimigo.com/en): a Mac app for supervising Claude Code and Codex on your own machines. Public beta 0.9.0-beta.8.
- [For companies](https://scimigo.com/en/for-companies): a developer-education studio that builds verified courses, failure-driven labs, workshops, technical visualizations, and grounded AI support for infrastructure products.
These are distinct audiences. The Learn page is the source for learner-facing course discovery. The For companies page is the source for SciMigo's developer-education services.
## SciMigo Code downloads
Current public Mac beta: 0.9.0-beta.8. Requires macOS 13.0 or later. Both builds are Developer ID signed and Apple notarized.
- [Apple silicon (M1 or later)](https://downloads.uubright.com/desktop/beta/SciMigo-0.9.0-beta.8-mac-arm64.dmg)
- [Intel Mac](https://downloads.uubright.com/desktop/beta/SciMigo-0.9.0-beta.8-mac-x64.dmg)
- [Installation and update instructions](https://scimigo.com/en#download)
Local agent tasks use the user’s own Claude Code or Codex login. Paid SciMigo tools are optional and require explicit approval. The phone client is a Home Screen web app; this download is the Mac desktop app.
## Teaching method
- Individual learners write code, run it, see state change, test what breaks, and explain the evidence.
- Infrastructure education begins with the real product, a working reference implementation, and observed behavior under failure—not a summary of documentation.
- AI assistance supports verified course material; it is not the primary product claim.
## Primary pages
- [Learn with SciMigo](https://scimigo.com/en/learn)
- [SciMigo Code](https://scimigo.com/en)
- [Developer education for companies](https://scimigo.com/en/for-companies)
- [Articles](https://scimigo.com/en/blog)
## Attribution and availability
Use the audience, availability label, module count, and prerequisites shown on the referenced page. Do not infer that an early-access or planned course is complete, or that a course is free or paid when the page does not say so.
## Courses
Course pages describe their current access and availability. Lesson pages with a narrated lecture include its full text transcript.
### Linear Algebra for AI
- [Course overview](https://scimigo.com/en/learn/linear-algebra): Master the language of AI: vectors, matrices, transformations, and eigenvalues -- with Python code to ground every concept. From NumPy basics to LoRA fine-tuning and mechanistic interpretability.
- Sources: Inspired by Gilbert Strang's MIT 18.06, 3Blue1Brown's Essence of Linear Algebra, and modern AI research (LoRA, mechanistic interpretability, quantization).
- [Vectors: The Language of Data](https://scimigo.com/en/learn/linear-algebra/01-vectors-the-language-of-data): Vectors are the atoms of linear algebra and the native data format of AI. This module builds your intuition from geometric arrows to NumPy arrays. You'll learn vector addition, scalar multiplication, and the dot product -- then discover that dot products measure similarity, the idea behind cosine similarity in recommendation systems and LLM embeddings. Visualize everything with matplotlib so the geometry clicks before the formulas.
- [Matrices as Transformations](https://scimigo.com/en/learn/linear-algebra/02-matrices-as-transformations): Matrices aren't just grids of numbers -- they are linear transformations. This module teaches matrix addition, multiplication, and transposition, but always through the lens of geometry: rotation, scaling, shearing, and projection. You'll visualize each operation with matplotlib, watching the unit square deform in real time. This geometric framing is essential because every layer of a neural network is a matrix transformation.
- [Systems of Linear Equations](https://scimigo.com/en/learn/linear-algebra/03-systems-of-equations): Most of applied math reduces to solving Ax = b. This module teaches you Gaussian elimination and row reduction -- the algorithmic backbone of linear algebra. You'll see how systems of equations correspond to intersecting hyperplanes, understand when solutions exist (and when they don't), and implement row reduction in Python.
- [Vector Spaces and Subspaces](https://scimigo.com/en/learn/linear-algebra/04-vector-spaces-and-subspaces): This module introduces the abstract structure that unifies all of linear algebra: vector spaces. You'll learn what it means for vectors to be linearly independent, what 'span' really means, and why choosing the right basis simplifies everything. These concepts are the vocabulary you need to understand PCA, SVD, and embedding spaces.
- [Determinants and Inverses](https://scimigo.com/en/learn/linear-algebra/05-determinants-and-inverses): The determinant tells you how a matrix transformation scales area (or volume). If it's zero, the transformation crushes space into a lower dimension -- and the matrix has no inverse. This module builds geometric intuition for determinants, then connects to matrix invertibility. You'll compute determinants and inverses by hand and with NumPy.
- [Linear Transformations](https://scimigo.com/en/learn/linear-algebra/06-linear-transformations): Now that you know matrices are transformations, this module digs deeper: what gets sent to zero (the kernel), what the transformation can produce (the image), and the fundamental rank-nullity theorem that connects them. You'll also learn change of basis -- the technique behind diagonalization, PCA, and every 'feature extraction' pipeline in ML.
- [Eigenvalues and Eigenvectors](https://scimigo.com/en/learn/linear-algebra/07-eigenvalues-and-eigenvectors): Eigenvectors are the directions a matrix only stretches (never rotates). Eigenvalues tell you how much. This module builds geometric intuition first -- watching vectors get transformed and identifying the special ones that stay on their line -- then covers the characteristic polynomial and diagonalization. The payoff: eigenvalues are the key to PCA, Google's PageRank, and stability analysis.
- [PCA: Dimensionality Reduction](https://scimigo.com/en/learn/linear-algebra/08-pca-dimensionality-reduction): Principal Component Analysis is eigenvalues applied to data. You compute the covariance matrix of your dataset, find its eigenvectors (the principal components), and project onto the top-k directions of maximum variance. This module is the bridge from abstract eigenvalue theory to practical ML: you'll reduce a real dataset from high dimensions to 2D and visualize the clusters that emerge.
- [Singular Value Decomposition](https://scimigo.com/en/learn/linear-algebra/09-svd-and-low-rank-approximation): SVD decomposes any matrix (not just square ones) into three factors: U * Sigma * V^T. The singular values in Sigma tell you how much 'information' each component carries. By keeping only the top-k singular values, you get the best rank-k approximation -- this is the mathematical foundation of image compression, latent semantic analysis, and (crucially) LoRA fine-tuning. This module builds from the geometry of SVD to hands-on applications.
- [Embeddings: From Words to Vectors](https://scimigo.com/en/learn/linear-algebra/10-embeddings-from-words-to-vectors): An embedding is a learned linear map from a discrete set (words, users, products) into a continuous vector space. This module covers the geometry of embeddings: why king - man + woman = queen works, how sentence embeddings capture semantic meaning, and what it means for LLM token embeddings to live in a 12,288-dimensional space. You'll also confront the curse of dimensionality -- why intuition breaks in high dimensions.
- [Vector Search at Scale](https://scimigo.com/en/learn/linear-algebra/11-vector-search-at-scale): Once you have millions of embeddings, brute-force cosine similarity is too slow. This module covers approximate nearest neighbor (ANN) algorithms that trade a tiny bit of accuracy for massive speedups. You'll learn locality-sensitive hashing, IVF (inverted file index), HNSW (hierarchical navigable small world graphs), and product quantization. Then see how vector databases (pgvector, Qdrant, Pinecone) wrap these algorithms into production infrastructure for RAG and recommendation systems.
- [Neural Networks as Linear Algebra](https://scimigo.com/en/learn/linear-algebra/12-neural-networks-as-linear-algebra): A dense neural network layer is just y = Wx + b -- a matrix multiplication plus a bias vector, followed by a nonlinear activation. This module strips away the deep learning mystique and shows you the linear algebra at the core. You'll manually implement a forward pass using only NumPy, then extend to tensors (3D+ arrays) that represent batches of images and sequences. Finally, you'll see that PyTorch's torch.Tensor is just NumPy with autograd.
- [The Attention Mechanism](https://scimigo.com/en/learn/linear-algebra/13-the-attention-mechanism): Attention is the innovation behind transformers, and it's pure linear algebra. This module derives scaled dot-product attention step by step: project inputs into Query, Key, and Value matrices, compute attention scores via QK^T/sqrt(d), apply softmax, then multiply by V. You'll see that multi-head attention is just running several smaller attention operations in parallel -- a block-diagonal matrix structure. No black boxes.
- [LoRA: Low-Rank Adaptation](https://scimigo.com/en/learn/linear-algebra/14-lora-and-low-rank-adaptation): LoRA is the most practical application of matrix decomposition in modern AI. Instead of updating a giant weight matrix W (d x k parameters), you freeze W and train two small matrices B (d x r) and A (r x k) where r << d, so the update is Delta-W = B*A. This module connects SVD theory to practice: you'll understand why weight updates tend to be low-rank, implement a LoRA layer from scratch, and see how this enables fine-tuning LLMs on consumer hardware.
- [Mechanistic Interpretability](https://scimigo.com/en/learn/linear-algebra/15-mechanistic-interpretability): Mechanistic interpretability is the 'forensics' of AI: researchers use linear algebra to decode what individual neurons and layers actually represent. The key insight is the Linear Representation Hypothesis -- high-level concepts like 'truthfulness,' 'sentiment,' or 'programming language' are encoded as linear directions (vectors) in activation space. You can find these directions, measure them, and even add or subtract them to steer model behavior. This module covers probing classifiers, activation steering, and concept vectors.
- [Quantization: Precision vs. Speed](https://scimigo.com/en/learn/linear-algebra/16-quantization-precision-vs-speed): As models grow to hundreds of billions of parameters, storing every weight in 32-bit float becomes impractical. Quantization maps continuous values to a smaller discrete set using affine transformations: Q = round(W/S + Z). This module covers the linear algebra of quantization: why it's an affine transformation, how it distorts the vector space, why 'outlier features' break naive approaches, and how techniques like GPTQ, AWQ, and SmoothQuant handle this. You'll implement basic quantization and measure the accuracy/speed tradeoff.
### Meta System Design Interview
- [Course overview](https://scimigo.com/en/learn/meta-system-design): What Meta actually tests, how it evaluates, and how to think at Staff level. 27 episodes covering distributed systems fundamentals, 13 real Meta-style design problems, and capstone mock interviews.
- Sources: Original curriculum inspired by publicly available Meta engineering blog posts, InfoQ talks, and the experiences of Staff+ engineers.
- [M0 How Meta System Design Interviews Work](https://scimigo.com/en/learn/meta-system-design/01-how-meta-interviews-work): Understand the Meta system design interview format: 45-minute structure, the 4 evaluation signals (Problem Exploration, Design & Architecture, Communication, Tradeoffs), how IC4/IC5/IC6 answers differ, and common mistakes that tank interviews.
- [M1 The Meta Design Framework](https://scimigo.com/en/learn/meta-system-design/02-meta-design-framework): Learn a structured framework for Meta SD interviews: Scope → Estimate → Design → Evaluate. Each phase maps directly to Meta's evaluation signals. Practice applying it to a warm-up problem.
- [M1 Estimation for Meta](https://scimigo.com/en/learn/meta-system-design/03-estimation-for-meta): Master capacity estimation for Meta-scale systems. Learn the key numbers (DAU, QPS, storage ratios), practice estimation workflows, and understand how to use estimates to drive design decisions — not just as a checkbox exercise.
- [F1 Consistent Hashing & Partitioning](https://scimigo.com/en/learn/meta-system-design/04-consistent-hashing): Master consistent hashing: the hash ring, virtual nodes, rebalancing on node add/remove, and bounded-load variants. Then connect it to real Meta use cases — Memcache shard routing, TAO partition assignment, rate limiter bucket distribution, and Kafka partition assignment.
- [F1 Redis — Crash Course to Advanced Patterns](https://scimigo.com/en/learn/meta-system-design/05-redis-crash-course): Redis fundamentals and advanced patterns for system design interviews. Cover data structures (strings, hashes, sorted sets, HyperLogLog, streams), persistence modes (RDB/AOF), replication and Redis Cluster, then dive into advanced use cases: distributed rate limiting (token bucket via Lua scripts), real-time Top-K (sorted sets + probabilistic structures), leaderboards, session stores, and pub/sub.
- [F1 Kafka & Event-Driven Architecture](https://scimigo.com/en/learn/meta-system-design/06-kafka-event-streaming): Kafka fundamentals and event-driven architecture for system design interviews. Cover topics, partitions, consumer groups, offset management, and delivery guarantees (at-least-once, exactly-once). Then connect to Meta patterns: Scribe/LogDevice as Meta's Kafka equivalent, event sourcing for notifications, click-stream pipelines for ad analytics, and CDC for cache invalidation.
- [F1 Graph Storage & TAO Internals](https://scimigo.com/en/learn/meta-system-design/07-graph-storage-tao-internals): Deep dive into Meta's TAO (The Associations and Objects): the objects-and-associations data model, read-after-write consistency via cache invalidation, the MySQL + cache architecture, association queries (assoc_get, assoc_count, assoc_range), write-through caching, and cross-region replication. Builds the foundation for the Design Social Graph module.
- [F1 Leader Election & Distributed Coordination](https://scimigo.com/en/learn/meta-system-design/08-leader-election): Leader election protocols and distributed coordination for system design interviews. Cover why leader election is needed, the Raft consensus algorithm (leader election, log replication, safety), ZooKeeper's coordination primitives (ephemeral nodes, watches, sequential nodes), and practical applications: Kafka controller election, distributed locks, config management, and service discovery.
- [M2 Design Instagram Feed](https://scimigo.com/en/learn/meta-system-design/09-design-instagram-feed): Design Instagram's home feed end-to-end: post ingestion, fan-out strategies (push vs pull vs hybrid), feed ranking, and timeline serving. Understand how Meta handles celebrity accounts, cold-start users, and real-time updates.
- [M2 Design Facebook News Feed](https://scimigo.com/en/learn/meta-system-design/10-design-facebook-newsfeed): Design the Facebook News Feed, which differs from Instagram by aggregating content from friends, pages, groups, and ads. Cover the evolution from EdgeRank to ML-based ranking, story aggregation, and the unique challenges of multi-source feeds.
- [M2 Design Messenger](https://scimigo.com/en/learn/meta-system-design/11-design-messenger): Design Facebook Messenger: real-time 1:1 and group messaging, online presence, message delivery guarantees (sent/delivered/read), offline message queuing, and end-to-end encryption considerations.
- [M2 Design WhatsApp at Scale](https://scimigo.com/en/learn/meta-system-design/12-design-whatsapp): Design WhatsApp, which handles 2B users with a famously small engineering team. Focus on what differentiates WhatsApp from Messenger: end-to-end encryption by default, media message handling, status/stories, and the Erlang-based backend architecture.
- [M2 Design Notification System](https://scimigo.com/en/learn/meta-system-design/13-design-notification-system): Design Meta's notification system: real-time push delivery across iOS, Android, and web; notification ranking and priority; deduplication and rate limiting to avoid spamming users; offline queuing and batching; notification preferences and muting.
- [M2 Design Live Video Streaming](https://scimigo.com/en/learn/meta-system-design/14-design-live-video-streaming): Design a live video streaming platform like Facebook Live / Instagram Live: real-time video ingest and transcoding, adaptive bitrate streaming, CDN distribution, live comments and reactions overlay, viewer count tracking, and recording for replay.
- [M3 Design Distributed Cache](https://scimigo.com/en/learn/meta-system-design/15-design-distributed-cache): Design a distributed caching system inspired by Meta's Memcache deployment. Cover cache topologies, consistency models, eviction strategies, thundering herd mitigation, and cross-datacenter cache invalidation.
- [M3 Design Social Graph (TAO)](https://scimigo.com/en/learn/meta-system-design/16-design-social-graph-tao): Design a social graph storage system inspired by Meta's TAO. Cover the objects-and-associations data model, read-after-write consistency, caching graph queries, and handling the friend-of-friend query pattern at billions of nodes.
- [M3 Design Rate Limiter](https://scimigo.com/en/learn/meta-system-design/17-design-rate-limiter): Design a distributed rate limiting system for Meta's API platform. Cover rate limiting algorithms (token bucket, sliding window, fixed window), distributed coordination, per-user and per-API limits, and graceful degradation under load.
- [M4 Design Typeahead / Autocomplete](https://scimigo.com/en/learn/meta-system-design/18-design-typeahead-autocomplete): Design a typeahead autocomplete system for Meta search: prefix-based suggestion with sub-100ms latency, personalized ranking, multi-entity results (people, pages, groups, posts), real-time index updates, and handling of trending queries.
- [M4 Design Trending Topics (Top-K)](https://scimigo.com/en/learn/meta-system-design/19-design-trending-topics-topk): Design a trending topics system that identifies the top-K most discussed topics across Meta's platform in real time. Cover streaming aggregation, approximate counting algorithms (Count-Min Sketch, HeavyKeeper), time-windowed rankings, spam/bot filtering, and geographic trending.
- [M4 Design Ad Click Analytics](https://scimigo.com/en/learn/meta-system-design/20-design-ad-click-analytics): Design Meta's ad click analytics system: real-time ingestion of click/impression events, exactly-once counting for billing accuracy, multi-dimensional aggregation (by campaign, audience, geo, time), near-real-time dashboards for advertisers, and fraud detection.
- [M4 Design Real-Time Ranking System](https://scimigo.com/en/learn/meta-system-design/21-design-realtime-ranking): Design a real-time ranking system for feed, search, and recommendations at Meta scale. Cover feature stores, online vs offline features, model serving infrastructure, and the candidate generation → ranking → re-ranking pipeline.
- [M4 Design Experimentation Platfo