Vibe Coder Engineering

• What a program actually is: CPU, RAM, disk, processes
• Linux filesystem, permissions, ssh, tmux, env vars
• Git: branches, merges, rebase — the AI writes code, YOU manage history
• Reading errors: stack traces, exit codes, journalctl

payoff — Every agent failure is a file, process, permission, or log line. After this module, they're all readable.

• Types, collections, comprehensions, functions, decorators
• venv, pip, pyproject.toml — environments done right
• try/except, tracebacks, file/JSON/env handling
• asyncio basics, pytest, and enough regex to read AI-written code
• Hands-on from minute one: the real tiktoken tokenizer demo

payoff — The whole AI ecosystem is Python. If you can read it, you can steer it.

• The event loop: callbacks → promises → async/await
• DOM, devtools, and debugger-driven development
• npm, package.json, lockfiles
• TypeScript types — the AI's best friend
• Node servers (Express 5) and React/Next reading literacy

payoff — Reading JS/TS fluently is the difference between 'hope it works' and 'I reviewed it'.

• Ownership and borrowing — the one idea everything else follows
• Memory safety vs garbage collection: what Python and JS pay for you
• cargo, crates, Result and the ? operator
• Where Rust lives: llama.cpp, vLLM kernels, Tauri, routers, wasm

payoff — Every serious LLM runtime is Rust or C++. Under the hood, it's everywhere.

• Methods, the 15 status codes you'll actually see, headers, CORS
• JWT anatomy: header.payload.signature — not encrypted, never trust it blindly
• API keys vs OAuth2 vs sessions: who uses what and why
• Webhook security: HMAC signature verification (the Stripe pattern)
• curl workflows, Bruno collections in git, pytest + respx mocking
• OpenAPI: docs that can't drift — and the fastest way to brief an agent

payoff — 80% of vibe coding is wiring APIs together. This removes the magic.

• FastAPI vs Express 5: the same CRUD app in both
• SQL essentials: CREATE, JOIN, INDEX, EXPLAIN ANALYZE
• Postgres vs MySQL vs SQLite — the decision guide
• Alembic migrations with a CI gate
• Redis cache-aside, background jobs (Celery/RQ, BullMQ)
• Secrets, logging (structlog/pino), Sentry, cookie security flags

payoff — Agents build backends fast — you must know which parts are dangerous (auth, money, data loss) and which are plumbing.

• Docker: images, Compose, volumes, healthchecks
• nginx reverse proxy + Let's Encrypt (certbot)
• GitHub Actions: test on push, deploy on merge
• systemd, cron, journalctl
• Monitoring (UptimeRobot, Sentry) and backups with a restore drill
• Zero-downtime: rolling deploys and blue-green via nginx
• VPS vs managed pricing — what things actually cost

payoff — 'Works on my machine' ends here. This module separates hobbies from businesses.

• BPE tokenizers: why 'strawberry' hides its double r inside one token
• The transformer: attention, layers, parameters, context windows
• Next-token prediction and sampling (temperature, top-p)
• The training pipeline: pretraining (15T tokens, a $5.6M DeepSeek) → SFT → RLHF/DPO/GRPO → reasoning RL
• Fine-tune vs RAG vs prompt — the three tools and when to use each
• Embeddings and why similar text lands in similar vectors

payoff — Every confusing AI behavior — hallucination, context loss, 'it forgot' — is explained here. Mechanism kills superstition.

• The OpenAI-compatible API as the universal interface, SSE streaming
• Structured output: JSON mode and function calling
• VRAM math: weights, quantization (Q4_K_M), KV cache sizing
• Ollama, llama.cpp/GGUF, vLLM — local and production serving
• The 2026 model landscape with real $/M token pricing
• Routers, fallbacks, retries — and cost governance (budgets, caching, tiering)

payoff — Every agent tool you use is this stack in a trench coat. Build it once by hand and nothing is magic anymore.

• The agent loop: perceive → reason → act → observe (ReAct)
• Tools and function calling; MCP servers you build yourself
• RAG: chunking, embeddings, vector DBs, retrieval, reranking
• Memory, evals in CI (promptfoo, DeepEval, RAGAS), observability (Langfuse)
• Guardrails: prompt injection, sandboxing, human-in-loop for money paths
• Context engineering, spec-driven development, review-before-merge
• When NOT to use AI — and when not to vibe

payoff — Tool competence is commoditizing. Context engineering and review discipline are the durable skills.

• Real auth + database, LLM integration (API and/or self-hosted)
• One tool-use / agent feature
• Tests, CI/CD, backups with a restore drill, uptime monitoring
• Cost tracing per query (Langfuse)
• A written postmortem: what broke, why, how you fixed it

payoff — Everything above, on one real product you own.