Building a mod that blocks npm commands that skip a wrapper script and adds a /node-guard command: the files, claude plugin validate, a test, running it, letting Claude write it, and the pitfalls.
A mod is a plugin whose JavaScript or TypeScript runs inside Claude Code. How it works, when to pick it over a hook, skill or MCP server, the layers it runs in, and its risks. Version 2.1.295.
Two steps beyond a fixed RAG pipeline: letting the model search as a tool, as many times as it needs, and building a knowledge graph for questions that span many documents.
What makes a system an agent, how it differs from a workflow, when an agent is worth it and when it is not, a minimal agent in Python, and the Claude Agent SDK.
Agents that operate a desktop through screenshots, mouse and keyboard, and skills: folders of instructions and scripts that give an agent expertise only when it needs it.
Where the money and time go in an LLM system, and the levers that cut them: the right model and effort, shorter outputs, prompt caching, the Batch API and streaming.
The whole series in one place: a decision map for choosing the right technique, what each one changes and costs, a worked example, and a checklist before going to production.
What knowledge distillation is, why a teacher's soft probabilities teach more than the right answer, and how distillation of LLMs works in practice: teacher data, filtering, fine-tuning a student.
What an embedding is, how cosine similarity finds texts that mean the same thing, how to create embeddings with Voyage AI, and where to store them.
One small app built with the whole series: a prompt, RAG over help articles, a tool for live order data, input screening, evals, caching and logging. Each step links to the post that explains it.
Why every LLM system needs an evaluation set, how to build one, code-based checks, LLM-as-judge with a rubric, and how to use evals to compare prompts, models and settings.
When fine-tuning beats prompting and RAG, and when it does not, what training data looks like, how LoRA and QLoRA train a model cheaply, and how to check the result.
The AI terms from the series in one place, grouped by topic, each with a one-line definition and a link to the post that explains it: tokens, RAG, tools, MCP, agents, LoRA, evals and more.
Layered guardrails for LLM applications: screening input with a small model, validating and redacting output, checking actions, limits, and what to show the user when a check fails.
Transformers, attention, pretraining, fine-tuning and preference training (RLHF, DPO): the stages that turn a pile of text into a chat assistant.
Why run an open-weight model on your own machine, how much memory it needs, what quantization does, and how to call a local model with Ollama, including from the Anthropic SDK.
What MCP is, why it exists, hosts, clients and servers, tools, resources and prompts, the two transports, and a small MCP server in Python.
How agents keep working when a task outgrows the context window: context engineering, compaction, clearing tool results, notes and the memory tool, with safe file handling.
When several agents beat one: the orchestrator-subagent design, what Anthropic measured in its research system, the token cost, and subagents in the Claude Agent SDK.
Sending images and PDFs to a model, how image tokens are counted, what vision is still bad at, and what to do with audio.
What to log for every model call and agent step, traces and spans, a tiny tracer in Python, the metrics worth watching, privacy, and turning production failures into evals.
How the next token is picked, what temperature and top-p do, why current Claude models no longer accept them, and why models hallucinate.
The system prompt, clear instructions with a reason, few-shot examples, XML tags and long documents: the prompting techniques the official guide recommends.
Three techniques that fix most RAG retrieval failures: combining keyword and vector search, reranking the candidates, and adding context to every chunk.
The full RAG pipeline: when you need it, splitting documents into chunks, retrieving the closest ones, and building a prompt that answers only from them.
What thinking is, how adaptive thinking and the effort parameter control it, how to read thinking blocks, and what it costs.
The main risks of LLM apps, from prompt injection to excessive agency, and the defenses that work: keeping data apart from instructions, least privilege and screening.
Get JSON that always matches your schema with structured outputs and Pydantic, and show the answer while it is being written with streaming.
What a token is, how to count tokens before you send a request, what fills the context window, and what happens when it runs out.
How a model calls your functions: defining a tool, the tool use loop, tool results and errors, the raw JSON on the wire, the SDK's tool runner, and how to write good tools.
What WebMCP is and how it relates to MCP: a page registers tools with document.modelContext, forms become tools with two attributes, annotations, iframes, testing in Chrome, and the security risks.
Prompt chaining, routing, parallelization, orchestrator-workers and evaluator-optimizer: the patterns that solve most LLM tasks without a full agent, with short Python for each.
What GitHub Actions is, the parts of a workflow, a first CI workflow for a Node project, reading runs with gh, and the events that start a workflow: push, pull_request, manual and scheduled.
Growing a workflow: job options, jobs that wait for each other, expressions and contexts, passing values between steps and jobs, matrix builds, caches and artifacts.
Reusable workflows and composite actions, concurrency groups, the security habits that keep a workflow from becoming a back door, debugging a failed run, and what Actions costs.
Secrets and variables, the GITHUB_TOKEN and its permissions, environments with required reviewers, deploying to a cloud with OIDC instead of stored keys, and a pipeline that pushes a Docker image.
What Kubernetes is and the desired-state idea, the parts of a cluster, a local cluster with kind, a first Pod, and how manifests describe objects in YAML.
Run hello-app as a Deployment that keeps three copies alive, give it a stable address with a Service, compare Service types, and route outside traffic with Gateway API or Ingress.
Persistent volumes and StatefulSets, namespaces and kubectl contexts, a debugging routine with the common Pod statuses, Kustomize and Helm, and a production checklist.
Update hello-app without downtime and roll back, pass settings with ConfigMaps and Secrets, add readiness and liveness probes, set requests and limits, and scale with an HPA.
What a code block is in Python, why if, for, while and try don't create a new scope, which blocks do (functions, classes, comprehensions), and the bugs that come from mixing them up.
A dict stores values by key instead of by position. Creating one, reading safely with get, adding and removing, looping over keys and values, counting, nesting, and the keys you can use.
What happens when Python hits an error at runtime: reading a traceback, catching errors with try/except, else and finally, raising your own exceptions, and why a bare except is a trap.
def, parameters and return values, default and keyword arguments, the mutable default trap, docstrings and type hints, and passing a function as a value.
How Python decides which code to run: if, else and elif, the comparison operators, truthy and falsy values, the conditional expression (x if C else y), and a first look at match.
A list holds many values in order. Creating one, indexing and slicing, adding and removing items, sorting, copying without surprises, and a word on tuples.
How and, or and not combine conditions in Python: truth tables, short-circuit evaluation, why and/or return one of their operands, precedence, and any() and all().
Running code again and again: for over a list or a range, enumerate and zip, while, break and continue, the else clause on a loop, and the loop bugs everyone writes once.
What % does in Python and where it's useful: even or odd, every Nth item, wrapping around a list or a clock, splitting seconds with divmod, digits, FizzBuzz, and how it treats negative numbers.
A large language model predicts the next token, over and over. What that means, what it gets you, and your first API call to one in Python.
How to work with dates in Python using datetime.date: creating dates, reading parts of a date, formatting with strftime and isoformat, date arithmetic with timedelta, and invalid dates.
How f-strings work in Python: putting expressions in braces, format specs for width, alignment, precision, thousands separators and percentages, the = debug specifier, and !r conversions.
How Python uses indentation to group code, the four IndentationError messages you'll meet, why tabs and spaces can trigger a TabError, and how to find and fix them.
How input() reads a line from the user in Python: the prompt, why the result is always a str, converting it with int() and float(), the ValueError on bad input, and EOFError.
The arithmetic operators in Python: + - * / // % and **, the difference between true and floor division, round, the math module, and why floats aren't exact.
How pip installs third-party packages from PyPI: install, pin versions, list, show, freeze into requirements.txt, uninstall, and why to use a virtual environment with python -m pip.
How print() works in Python 3: printing several values, the sep and end arguments, printing to stderr, and the common mistake of printing None.
Where a variable can be seen and changed in Python: local, global and nonlocal scope, the global and nonlocal keywords, shadowing, and how to choose clear names that follow PEP 8.
Python strings: quotes and escapes, raw and triple-quoted strings, indexing and slicing, immutability, the common str methods for changing, splitting and searching text.
How to convert between Python types with int(), float(), str(), bool(), list(), tuple() and set(): what each conversion does, truncation, bases, truthiness, and the errors when a conversion fails.
The common TypeError messages in Python and what they mean, checking types with type() and isinstance(), why type hints are not enforced, and when to check types versus catching the error.
What uv is and how to use it: the project workflow with uv init, uv add and uv run, the .venv, pyproject.toml and uv.lock, plus uv venv and uv pip for pip-style work.
How variables work in Python: assignment, names, the basic types int, float, str, bool and None, type(), and the NameError.
What AWS is and the shared responsibility model, Regions and Availability Zones, protecting the root user, the free plan, and a budget before you create anything.
Launching and connecting to an EC2 instance and what it costs, a VPC with public and private subnets across two zones, and a managed RDS database the internet can't reach.
Users, roles and policies in IAM and the best practices that matter, signing in to the AWS CLI with short-term credentials and profiles, and storing files in S3 buckets safely.
Running code on events with Lambda, watching it with CloudWatch and CloudTrail, which service to reach for, and the five causes of nearly every surprise AWS bill.
What Docker is, images, containers and registries, how containers differ from VMs, installing it, running and managing your first container, and image tags.
Running the app and its database from one compose.yaml with health checks, the Compose commands, a debugging toolbox, freeing disk space, and habits for production images.
Containerizing a small Node app: writing a Dockerfile and .dockerignore, building and running it, layers and the build cache, multi-stage builds, and CMD versus ENTRYPOINT.
Connecting containers to the world: publishing ports safely, volumes, bind mounts and tmpfs, user-defined networks for containers that talk by name, and passing configuration and secrets.
The Linux commands worth knowing by heart, grouped by task: files, searching, text, permissions, processes, services and logs, disk, networking, archives, packages, SSH and shell tricks.
What Python is, what it's good for, and how it differs from languages like C and Java: interpreted, dynamically typed, indentation-based and batteries included.
The Git commands I keep coming back to, grouped by what you're doing: daily work, branches, undoing, remotes, history, worktrees and more.
Part 1 of the Git guide: what Git is, a one-time setup, a first repository, the three areas a change passes through and the four states of a file.
Part 4 of the Git guide: what a branch really is, fast-forward and merge commits, how a three-way merge decides, and how to resolve a conflict calmly.
Part 2 of the Git guide: how to read git diff, what each diff command compares, good commit messages, git log, and what a commit really contains.
Part 5 of the Git guide: rebase and the one rule that comes with it, interactive rebase to tidy commits, then stash, cherry-pick, bisect and .gitignore.
Part 6 of the Git guide: clone, push, fetch and pull, remote-tracking branches and ahead/behind, what to do when a push is rejected, force-with-lease and tags.
Part 3 of the Git guide: naming commits (HEAD~1, HEAD^2, HEAD@{2}), detached HEAD, and the right undo for each mistake: restore, amend, reset, revert and reflog.
Part 1 of the GitHub guide: what GitHub adds to Git, creating a repository, signing in with gh, an SSH key or a token, and putting a project online.
Part 4 of the GitHub guide: a first Actions workflow, secrets and permissions, publishing a site with GitHub Pages, releases with generated notes, Codespaces and Copilot.
Part 3 of the GitHub guide: issues and labels, contributing to someone else's project through a fork, branch protection, CODEOWNERS and keeping a repository safe.
Part 2 of the GitHub guide: the GitHub flow step by step, a good pull request, reviewing with comments and suggestions, and the three ways to merge.
The Claude Code slash commands worth knowing, grouped by what you're doing. Checked against the official docs for v2.1.294.