Meta — LLM-scale training literacy

Literacy, not recreating GEM

Meta-scale training is thousand-GPU coordination, data preparation at petabyte scale, and efficiency research (GEM-class systems optimize memory and communication for massive models). Most product AI engineers never operate pretraining clusters — but they must speak the vocabulary when partnering with research, evaluating build-vs-buy, and understanding why serving SLMs locally differs from training Llama-class stacks.

This lesson is reading + brief + quiz, not a GPU lab.

What to extract from Meta engineering material

Focus on concepts applicable to career conversations:

1. Training vs inference split — different hardware profiles, different bottlenecks (FLOPs vs latency).
2. Parallelism types — data, tensor, pipeline — why one laptop cannot "just train" a frontier model.
3. Efficiency techniques — mixed precision, checkpointing, sharding — why they exist at scale.
4. Open-weight ecosystem impact — product teams fine-tune and serve; Meta-scale trains foundation.
5. Evaluation at scale — benchmark culture; not the same as your golden set, but related discipline.

Avoid copying paper math — summarize engineer-facing implications in industry/meta/brief.md (2–3 pages).

Callout — Serving ≠ training: Your Netflix gateway lab addresses inference. Meta reading addresses why foundation models cost millions — context for finetune vs API decisions in capstone.

Brief structure

brief.md sections:

• Executive summary — 5 bullets on what LLM-scale means
• Training stack sketch — ASCII diagram data → train → checkpoint → eval
• Implications for product engineers — when to partner with research vs ship RAG
• Implications for your portfolio — how Build & serve your SLM SLM work relates (LoRA, not GEM)
• Glossary — 10 terms (FSDP, MFU, etc.) in plain language

Short quiz

Commit industry/meta/quiz.md with 10 questions + answer key:

• Multiple choice and short answer
• Example: "Why is tensor parallelism used?" / "Name one reason product teams serve SLMs instead of running pretraining"
• Self-grade in README; honor system — quiz exists to force active reading

Optional: script check_quiz.sh that prompts questions interactively.

How this connects to industry module labs

Other labs are build. This lab is calibrate expectations — you will not hand Meta a GEM reimplementation in capstone; you will explain why their gateway + your SLM route is the sensible product architecture.

Anti-patterns in brief writing

• Buzzword soup without implications
• Treating open-weight weights as "free training"
• Ignoring data governance at scale

MFU and why product engineers nod politely

Model FLOPs utilization (MFU) measures how efficiently training uses GPU — low MFU means expensive idle time. You won't optimize MFU; you recognize when research says "training run cost $X" that inefficiency is engineering work at scale — informs respect for foundation model pricing.

Open weight vs API at scale

Meta releases weights; running them still requires serving investment. Brief should clarify: open weights reduce vendor lock-in, not operational cost — GPU RAM, engineering headcount, eval ownership remain yours.

Interview-ready talking points

From brief, prepare three sentences: difference data vs tensor parallel; why product teams fine-tune adapters not pretrain; one reason your capstone chose API vs local SLM — connects literacy lab to job conversations.

Putting it together in practice

ShipAI treats this lesson as executable curriculum, not reading alone. Before marking complete, trace one real request through your portfolio stack and label where this lesson's concepts apply — even if the first pass is messy. Document what broke in the module README; that gap list becomes your next sprint.

Compare your implementation against the industry callouts cited earlier without copying their scale. Name one deliberate simplification you kept (mock auth, SQLite not Postgres, single-region deploy) and one simplification you refuse to ship without (no eval gate, no trace on mutating tools, no fail-closed guardrail on exfil cases). That contrast is what interviewers and graders look for.

Callout — Teach back: Explain this lesson's core tradeoff to a peer in five minutes without slides. If you cannot, re-read the failure modes section and add an example from your own run logs.

Common questions and misconceptions

"Is this overkill for a side project?" Side projects can skip pieces; capstones and production cannot skip knowing the pieces exist. You may waive cost accounting in v1 but your architecture diagram should still show where it would attach.

"Should I rewrite from scratch?" Extend what you built in prior modules — graders reward evolution, not parallel unused folders. Link file paths in your checklist.

"Which metric matters most?" The metric tied to user harm or revenue: policy violations, failed refunds, silent wrong answers — not vanity leaderboard scores.

Extension paths after the micro-project

After the micro-project passes smoke check, choose one extension aligned with your capstone pillar: tighten eval coverage, add a chaos or red-team case, or wire observability into SSE streams. Extensions belong in BACKLOG unless scope freeze explicitly includes them — avoids capstone death by optional polish.

Engineering problem (staff framing)

Study public engineering patterns around Meta: Training scale literacy. Rebuild the idea, not scraped proprietary text — focus on transferable architecture.

Diagram — Meta pattern (conceptual)

flowchart LR
  Data-->Train[Large-scale train]-->Ckpt-->Eval

Precise definitions & mental model

Extract 3 transferable patterns from Meta's public tech narrative on Training scale literacy; map each to a ShipAI module artifact.

Tradeoffs — when to use what

Lens	Question
Scale	What breaks at 10× traffic?
Safety	Where are human/policy gates?
Cost	Where do tokens/GPUs dominate?

Failure modes (interview + on-call)

Cargo-culting brand names without metrics; inventing fake citations; cloning UI not architecture.

Production & OSS practices

Write a lab README: hypothesis, architecture diagram, eval, cost model, what you'd ask their eng in an interview.

Micro-project: Brief + quiz

Deliver:

1. Reading log with links and dates in notes.md.
2. brief.md per structure above.
3. quiz.md 10 questions with answers.
4. Self-score recorded in quiz_results.txt.
5. One discussion prompt for capstone proposal: build vs buy foundation model access.

Acceptance: brief readable standalone; quiz covers reading goals.

Checklist

• Meta reading notes with links
• brief.md with diagram and glossary
• quiz.md 10 Q&A committed
• Self-score documented
• Capstone implication paragraph written