Categories › AI Engineering
AI Engineering
LLM applications, RAG, embeddings, transformers, and the engineering choices behind production AI features.
How modern models work well enough to build on them: transformers and attention, embeddings and retrieval, prompting and structured output, fine-tuning decisions, inference optimization, and the system design that turns a model call into a product feature.
43 posts, from beginner to advanced. Each ends with what to read next.
Fine-Tuning and Post-Training: LoRA, SFT, DPO, and Reasoning RL
What actually happens after pretraining, and when you should do any of it yourself. Parameter-efficient fine-tuning with LoRA, supervised fine-tuning data, preference optimization, and the reinforcement learning recipe behind reasoning models, with a decision framework and a project you can run on one GPU.
LLM Context Windows: What They Mean for System Design
Context window size shapes every architectural decision in LLM applications. This post covers how to reason about context allocation, the limits that still matter even with large windows, and the patterns that scale.
Common ML Architectures Reference: CNN, RNN, Transformer, MoE
A concise technical reference for the neural network architectures that power modern ML - what each one does, how it works, when to use it, and what to watch out for.
Building a Streaming API With LLMs
Streaming transforms LLM user experience - users see the first token in under a second instead of waiting for full generation. This post covers the implementation patterns for both server and client.
Attention Is All You Need - But What Is Attention?
The attention mechanism is the core of every modern language model. This post explains what it computes, why it works, and how to reason about it when building with transformers.
Chunking Strategies for RAG: What Actually Works
Chunking is the most underrated decision in RAG system design. This post benchmarks the main strategies and gives you a framework for choosing and evaluating them.
Tokenization: The Part of LLMs Nobody Explains Well
LLMs do not see words or characters - they see tokens. Understanding tokenization explains why LLMs fail at some surprisingly easy tasks and how to work around it.
Structured Output From LLMs: Techniques and Tradeoffs
JSON, schemas, tool calling, constrained decoding - four ways to get parseable output from LLMs. Here is when to use which and how to handle each failure mode.
Vector Databases Compared: pgvector, Pinecone, Weaviate, Qdrant
Which vector database should you use? The answer depends on your scale, stack, and query requirements. Here is the tradeoff breakdown.
LLM Provider Comparison: Choosing the Right Model for Your Use Case
LLM models change fast. Use this framework to compare providers against your latency, quality, cost, privacy, and integration needs.
When to Fine-Tune vs. Prompt vs. RAG
Three tools for adapting LLMs to specific use cases. They solve different problems - picking the wrong one wastes months. This post gives you the decision framework.
How to Evaluate an LLM Application
Evaluation is the hardest part of LLM engineering. This post covers the evaluation stack: reference-based metrics, LLM-as-judge, task-specific evals, and how to build a reliable eval pipeline.
Building a RAG System From Scratch
A complete walkthrough of building a production-ready RAG system: document ingestion, chunking, embedding, vector search, reranking, and generation with citation.
Retrieval-Augmented Generation in Practice
RAG in production is harder than RAG in a demo. This guide covers chunking strategies, retrieval quality, reranking, failure modes, and the evaluation framework that tells you whether your system is actually working.
System Design for AI Products
AI system design is different from traditional system design. This guide covers the unique tradeoffs - quality vs. latency vs. cost, data pipelines, model serving, evaluation infrastructure, and how to structure these decisions in an interview.
Neural Networks and Transformers Basics
From perceptrons to transformers: the intuition behind neural network training, how attention works, why transformers replaced everything else, and what you need to know before using them.
Embeddings, Retrieval, and RAG Systems
Cover the most common product pattern in current AI systems: retrieval-augmented generation.
LLM Application Engineering
Building applications on top of large language models requires a different engineering discipline than training them. This guide covers prompt design, evaluation, reliability, and the production patterns that matter.
Transformers and Modern NLP Fundamentals
Bridge into LLM systems with practical understanding of tokenization, attention, and fine-tuning.
Transformer Inference and Context Engineering
Move from transformer intuition into serving reality: KV cache behavior, long-context tradeoffs, and prompt/context packing.
Sequence Models, Attention, and the Road to Transformers
Provide the conceptual bridge from older sequence models to attention-based systems.
RAG Evaluation and Failure Analysis
Treat retrieval-augmented generation as an evaluable system by separating retrieval, grounding, synthesis, and user-answer failure modes.
Fine-Tuning, Adaptation, and When Not to Fine-Tune
Teach mature decision-making about prompt engineering, RAG, and adaptation.
CNNs, Vision Pipelines, and Transfer Learning
Add one major non-tabular modality while teaching adaptation of pretrained models.
Deep Learning With PyTorch
Move from theory to practical model building in the most common deep learning framework.
Retrieval Systems, Vector Databases, and RAG
Teach the dominant product pattern in modern AI systems with retrieval quality as the core concern.
Neural Networks From Scratch
Build a neural network once from first principles so later deep learning abstractions make sense.
LLM Product Engineering
Focus on what teams actually ship with LLMs instead of toy chatbot wrappers.
Transformers and Modern NLP for Engineers
Move the learner into current AI engineering territory with strong transformer fundamentals.
CNNs or Domain Modeling Track: Vision / Time Series / Recsys
Introduce one specialization track so portfolio work can align with target roles.
Representation Learning, Embeddings, and Similarity
Bridge classical ML to retrieval and transformer-era systems through representation quality.
PyTorch for Real Model Development
Turn neural intuition into production-minded model development habits.
Neural Networks and Optimization for Practitioners
Provide enough deep learning foundations to go deeper confidently.
Inference Optimization and Performance
Optimize model serving latency and throughput while controlling quality and cost.
AI System Design and Reliability
Build reliable AI systems with SLO-driven architecture and operational safeguards.
RAG and Vector Search Systems
Engineer scalable retrieval systems with index strategy, reranking, and relevance metrics.
Deep Learning for Product Engineers
Learn deep learning choices that matter most for product behavior and reliability.
Milestone Gate 2: Applied AI Engineering
Validate your ability to debug, design, and communicate AI engineering tradeoffs.
AI System Design for Product Constraints
Design AI systems with explicit latency, cost, reliability, and governance tradeoffs.
LLM App Engineering
Build production-style LLM services with prompt design, tool use, and fallback behavior.
RAG Foundations and Retrieval Quality
Build retrieval pipelines and measure whether they return the evidence your product actually needs.
Transformers and Attention in Practice
Move from attention intuition to practical transformer architecture design decisions.
Neural Networks Fundamentals
Build intuition and implementation skill for dense networks, optimization, and regularization.