@shaykec/bridge 0.4.25 → 0.4.26

package/modules/llm-fundamentals/content.md

@@ -0,0 +1,114 @@
+# How LLMs Work — Tokens, Context Windows, and Model Behavior
+
+<!-- hint:slides topic="How LLMs work: tokenization, transformer architecture, attention mechanism, context windows, temperature, and model behavior" slides="6" -->
+
+## What Is an LLM?
+
+A **Large Language Model (LLM)** is a statistical model trained on vast amounts of text. It learns patterns in language — grammar, facts, reasoning, style — and uses those patterns to predict the next token. It doesn't "know" things in the human sense; it completes patterns based on what it was trained on.
+
+## Tokenization
+
+Text is broken into **tokens** — subword units (words, parts of words, punctuation). Most models use **BPE (Byte Pair Encoding)** or similar: common words are single tokens; rare words split into smaller pieces.
+
+- "Hello" → 1 token
+- "Claude" → 1–2 tokens
+- "unbelievable" → 2–3 tokens
+
+Token count affects cost and context limits. Roughly: 1 token ≈ 4 characters in English, 1–2 in code.
+
+## The Transformer Pipeline
+
+```mermaid
+flowchart LR
+    A[Input Text] --> B[Tokenize]
+    B --> C[Embed]
+    C --> D[Attention Layers]
+    D --> E[Generate Next Token]
+    E --> F[Detokenize]
+    F --> G[Output Text]
+```
+
+| Stage | What Happens |
+|-------|--------------|
+| **Tokenize** | Split input into tokens |
+| **Embed** | Map tokens to vectors (numerical representations) |
+| **Attention** | Model weights which tokens matter for the next prediction |
+| **Generate** | Predict next token (probabilistically) |
+| **Detokenize** | Convert tokens back to text |
+
+## Attention (Simplified)
+
+The **attention mechanism** lets the model look at all previous tokens and decide which ones are most relevant for predicting the next. "The cat sat on the mat" — when predicting "mat", the model attends strongly to "the" and "sat".
+
+## Context Windows
+
+The **context window** is the maximum number of tokens the model can "see" at once — prompt + response. If your prompt + response exceeds it, older tokens are dropped or truncated.
+
+- Small: 4K–8K tokens
+- Medium: 32K–128K tokens
+- Large: 200K+ tokens
+
+What fits: depends on model. 100K tokens ≈ 75K words ≈ a short book.
+
+## Next-Token Prediction
+
+At each step, the model predicts the **next token** from the distribution of possibilities. It doesn't plan ahead; it generates one token at a time. The choice is sampled (with temperature) from the predicted probabilities.
+
+## Temperature and Sampling
+
+- **Temperature 0** — Always pick the highest-probability token (deterministic).
+- **Temperature 0.5** — Slight randomness; mostly likely tokens.
+- **Temperature 1.0** — Sample proportionally to probability.
+- **Temperature 2.0** — More random; creative but less coherent.
+
+## Training vs Inference
+
+| Phase | Purpose |
+|-------|---------|
+| **Training** | Learn patterns from data; update weights; expensive, one-time (per model) |
+| **Inference** | Generate output; weights fixed; cost per token |
+
+## Fine-Tuning vs Prompting
+
+- **Prompting** — No model changes. You steer with instructions and examples. Fast, flexible.
+- **Fine-tuning** — Retrain on labeled data. Better for domain-specific behavior, but requires data and compute.
+
+## Why LLMs Hallucinate
+
+LLMs complete patterns — they don't verify facts. Hallucination occurs when:
+
+- The model confidently continues a plausible pattern that isn't true
+- Training data had errors or conflicting information
+- The prompt invites fabrication (e.g., "What did person X say in 2024?" when X said nothing)
+- Temperature is high, increasing randomness
+
+Mitigation: grounding (RAG), verification, lower temperature for factual tasks.
+
+## Emergent Abilities and Scaling Laws
+
+Larger models show **emergent abilities** — capabilities that appear suddenly at scale (e.g., few-shot learning, chain-of-thought). **Scaling laws** describe how performance improves with more data, parameters, and compute.
+
+## Model Families
+
+| Family | Examples | Notes |
+|--------|----------|-------|
+| GPT | GPT-4, GPT-4o | OpenAI; strong generalist |
+| Claude | Claude 3, Claude 3.5 | Anthropic; long context, safety |
+| Llama | Llama 3, Llama 3.1 | Meta; open weights |
+| Gemini | Gemini Pro, Ultra | Google; multimodal |
+
+## Safety and Alignment
+
+**RLHF (Reinforcement Learning from Human Feedback)** — Train a reward model from human preferences, then optimize the policy toward that reward. Reduces harmful outputs and improves helpfulness.
+
+**Alignment** — Making models behave according to human values: harmless, honest, helpful.
+
+---
+
+## Key Takeaways
+
+1. **Tokens** — Subword units; ~4 chars/token in English; drive cost and context limits
+2. **Transformers** — Tokenize → Embed → Attention → Generate → Detokenize
+3. **Context window** — Max tokens the model can use; older tokens dropped when exceeded
+4. **Hallucination** — Confident pattern completion without knowledge; use RAG, verification
+5. **Temperature** — Low = consistent; high = creative

package/modules/llm-fundamentals/exercises.md

@@ -0,0 +1,83 @@
+# LLM Fundamentals Exercises
+
+## Exercise 1: Token Budget Planning
+
+**Task:** You have a 4K context window. Your system prompt is 500 tokens. You want to include 3 few-shot examples (each ~150 tokens) and reserve 1K tokens for the response. How many tokens are left for the user's actual query? Express as a formula: `query_max = context - system - examples - response`.
+
+**Validation:**
+- [ ] Correct calculation: 4000 - 500 - 450 - 1000 = 2050 tokens
+- [ ] Can explain why each component consumes context
+
+**Hints:**
+1. Sum all fixed parts: system + examples + response reserve
+2. Remaining = context - fixed
+3. User query must fit in remaining
+
+---
+
+## Exercise 2: Compare Tokenization Across Inputs
+
+**Task:** Tokenize these with the same tool: (a) "The quick brown fox", (b) "def hello(): return 42", (c) "東京" (Tokyo in Japanese). Report tokens per character for each. Why do the ratios differ?
+
+**Validation:**
+- [ ] Reports token counts for all three
+- [ ] Notes that code and non-Latin may use more tokens per character
+- [ ] Can explain impact on cost/length for different input types
+
+**Hints:**
+1. Use OpenAI tokenizer or tiktoken
+2. Compare tokens / characters
+3. Code has many symbols; CJK often 1–2 chars per token
+
+---
+
+## Exercise 3: Design a Temperature Strategy
+
+**Task:** For each use case, choose temperature (0, 0.3, 0.7, 1.0) and write one sentence justifying it:
+1. Extracting JSON from a paragraph
+2. Brainstorming blog title ideas
+3. Answering "What is 2+2?"
+4. Writing a product description in a specific brand voice
+
+**Validation:**
+- [ ] Extraction: 0 or 0.3 (deterministic)
+- [ ] Brainstorm: 0.7–1.0 (creative)
+- [ ] Math: 0 (deterministic)
+- [ ] Brand voice: 0.3–0.5 (consistent but some variety)
+
+**Hints:**
+1. Factual/deterministic → low
+2. Creative/varied → high
+3. Brand voice: need consistency but not rigidity
+
+---
+
+## Exercise 4: Explain Hallucination in Your Own Words
+
+**Task:** Write a 2–3 sentence explanation of why LLMs hallucinate, suitable for a non-technical colleague. Use the concepts: pattern completion, no verification, confidence. Avoid jargon like "logits" or "softmax".
+
+**Validation:**
+- [ ] Mentions that the model completes patterns
+- [ ] Notes that it doesn't verify against knowledge
+- [ ] Explains that confidence ≠ correctness
+
+**Hints:**
+1. "The model predicts what comes next, not what is true"
+2. "It was trained on text patterns, not a fact database"
+3. "It can sound confident even when wrong"
+
+---
+
+## Exercise 5: Trace the Pipeline for a Short Sentence
+
+**Task:** For "The sky is", trace through: (1) How many tokens? (2) What might the model attend to when predicting the next token? (3) What are 3 plausible next tokens and why?
+
+**Validation:**
+- [ ] Correct token count (~4 tokens)
+- [ ] Identifies "sky" and "is" as highly relevant for "blue" / "cloudy" / etc.
+- [ ] Gives plausible completions with brief reasoning
+
+**Hints:**
+1. Tokenize first
+2. "Sky" + "is" → color/weather adjectives
+3. Plausible: blue, cloudy, gray, clear

package/modules/llm-fundamentals/module.yaml

@@ -0,0 +1,42 @@
+slug: llm-fundamentals
+title: "How LLMs Work — Tokens, Context Windows, and Model Behavior"
+version: 1.0.0
+description: "Understand tokens, tokenization, transformers, context windows, and why LLMs behave the way they do."
+category: ai-and-llm
+tags: [llm, ai, tokens, context-window, transformer, machine-learning]
+difficulty: intermediate
+
+xp:
+  read: 15
+  walkthrough: 40
+  exercise: 25
+  quiz: 20
+  quiz-perfect-bonus: 10
+
+time:
+  quick: 5
+  read: 25
+  guided: 50
+
+prerequisites: [prompt-engineering]
+related: [rag-fundamentals, ai-agents]
+
+triggers:
+  - "How do LLMs work?"
+  - "What are tokens in AI?"
+  - "What is a context window?"
+  - "Why do LLMs hallucinate?"
+
+visuals:
+  diagrams: [diagram-mermaid, diagram-architecture]
+  quiz-types: [quiz-matching, quiz-timed-choice]
+  playground: bash
+  slides: true
+
+sources:
+  - url: "https://www.anthropic.com/research"
+    label: "Anthropic Research"
+    type: research
+  - url: "https://arxiv.org/abs/1706.03762"
+    label: "Attention Is All You Need"
+    type: paper

package/modules/llm-fundamentals/quick-ref.md

@@ -0,0 +1,64 @@
+# LLM Fundamentals Quick Reference
+
+## Transformer Pipeline
+
+```
+Input → Tokenize → Embed → Attention → Generate → Detokenize → Output
+```
+
+## Token Basics
+
+| Concept | Value |
+|---------|-------|
+| ~1 token | ~4 characters (English) |
+| ~1 token | ~0.75 words |
+| BPE | Byte Pair Encoding (common tokenization) |
+
+## Context Window
+
+- Max tokens (prompt + response) the model can process
+- Exceeded → older tokens dropped
+- Sizes: 4K–8K (small), 32K–128K (medium), 200K+ (large)
+
+## Temperature
+
+| Range | Effect |
+|-------|--------|
+| 0 | Deterministic (always most likely token) |
+| 0.3–0.5 | Slight variation, factual tasks |
+| 0.7–1.0 | Creative, varied output |
+| >1 | Very random, often incoherent |
+
+## Training vs Inference
+
+| Phase | Purpose |
+|-------|---------|
+| Training | Learn from data; update weights |
+| Inference | Generate; weights fixed; pay per token |
+
+## Fine-Tuning vs Prompting
+
+| Approach | When |
+|----------|------|
+| Prompting | Fast, flexible; no model change |
+| Fine-tuning | Domain-specific; need labeled data |
+
+## Why Hallucination?
+
+- Model completes patterns; doesn't verify facts
+- Confident ≠ correct
+- Mitigate: RAG, verification, lower temperature
+
+## Model Families
+
+- **GPT** — OpenAI
+- **Claude** — Anthropic
+- **Llama** — Meta (open)
+- **Gemini** — Google
+
+## One-Liners
+
+- **Tokens** — Subword units; drive cost and context limits.
+- **Attention** — Model weights which tokens matter for next prediction.
+- **Context window** — Max tokens; overflow = truncation.
+- **Hallucination** — Confident pattern completion without knowledge.

package/modules/llm-fundamentals/quiz.md

@@ -0,0 +1,103 @@
+# LLM Fundamentals Quiz
+
+## Question 1
+
+What is a token?
+
+A) A security credential for API access
+B) A subword unit used to represent text — words or parts of words
+C) A type of neural network layer
+D) A unit of time in model training
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Tokens are subword units (words, word pieces, punctuation) that the model uses to represent text. Tokenization splits input into tokens before processing. -->
+
+## Question 2
+
+What happens when your prompt plus response exceeds the context window?
+
+A) The model automatically switches to a larger model
+B) The model runs faster
+C) Older tokens are dropped or truncated; the model can't use them
+D) The model compresses the text to fit
+
+<!-- ANSWER: C -->
+<!-- EXPLANATION: When the context window is exceeded, earlier tokens are typically dropped or truncated. The model cannot attend to tokens outside its context limit. -->
+
+## Question 3
+
+Why do LLMs hallucinate?
+
+A) They are programmed to make things up
+B) They complete patterns confidently without verifying facts
+C) They only hallucinate when temperature is 0
+D) Hallucination is always due to training data errors
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: LLMs predict the next token based on patterns. They can confidently complete plausible-sounding text that isn't true because they don't have a mechanism to verify facts. -->
+
+## Question 4
+
+Match the transformer stage to its role:
+
+<!-- VISUAL: quiz-matching -->
+
+A) Tokenize — Split text into subword units
+B) Embed — Map tokens to vectors
+C) Attention — Weight which tokens matter for prediction
+D) Generate — Predict next token
+
+<!-- ANSWER: All match correctly -->
+<!-- EXPLANATION: Tokenize splits input; Embed converts to vectors; Attention computes relevance; Generate produces the next token. -->
+
+## Question 5
+
+What does RLHF stand for and what is it used for?
+
+A) Reinforcement Learning from Human Feedback — aligning model behavior with human preferences
+B) Random Language Hyperparameter Finetuning — tuning model settings
+C) Recursive Layer Hidden Framework — a type of architecture
+D) Real-time Language Human Filter — content moderation
+
+<!-- ANSWER: A -->
+<!-- EXPLANATION: RLHF uses human feedback to train a reward model, then optimizes the policy toward that reward. It helps align model behavior with human values (helpful, harmless, honest). -->
+
+## Question 6
+
+What is the approximate token-to-character ratio for English text?
+
+A) 1 token = 1 character
+B) 1 token ≈ 4 characters
+C) 1 token = 1 word
+D) 1 token ≈ 10 characters
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: In English, roughly 1 token equals about 4 characters (or 0.75 tokens per word). This varies by language and content type. -->
+
+## Question 7
+
+<!-- VISUAL: quiz-matching -->
+
+Match each LLM concept to its description:
+
+A) Context window → 1) Maximum sequence length the model can process at once
+B) Temperature → 2) Subword units used to represent text
+C) Tokens → 3) Controls randomness; higher = more varied outputs
+D) Hallucination → 4) Model generating plausible but false or irrelevant content
+
+<!-- ANSWER: A1,B3,C2,D4 -->
+<!-- EXPLANATION: Context window is the max sequence length. Temperature controls output randomness. Tokens are subword units. Hallucination is confident generation of false or irrelevant content. -->
+
+## Question 8
+
+<!-- VISUAL: quiz-matching -->
+
+Match each model parameter to its typical effect:
+
+A) Temperature = 0 → 1) More deterministic, focused output
+B) Temperature = 1 → 2) More creative, varied output
+C) Top-p (nucleus) low → 3) Fewer token choices; more focused
+D) Top-p (nucleus) high → 4) Broader token sampling; more diversity
+
+<!-- ANSWER: A1,B2,C3,D4 -->
+<!-- EXPLANATION: Low temperature yields deterministic outputs; high temperature increases variety. Low top-p restricts to high-probability tokens; high top-p allows broader sampling. -->

package/modules/llm-fundamentals/resources.md

@@ -0,0 +1,30 @@
+# LLM Fundamentals — Resources
+
+## Official & Research
+
+- [Anthropic Research](https://www.anthropic.com/research) — Claude safety, scaling, and capabilities.
+- [Attention Is All You Need](https://arxiv.org/abs/1706.03762) — Original transformer paper (Vaswani et al.).
+
+## Videos
+
+- [3Blue1Brown — Neural Networks](https://www.youtube.com/watch?v=aircAruvnKk) — Visual intuition for neural networks.
+- [Andrej Karpathy — State of GPT](https://www.youtube.com/watch?v=bZQun8Y4L2A) — How GPT models work, training, and inference.
+- [Andrej Karpathy — Intro to Large Language Models](https://www.youtube.com/watch?v=zjkBMFhNj_g) — Conceptual overview of LLMs.
+- [AI Explained — How do LLMs work?](https://www.youtube.com/results?search_query=AI+Explained+LLM) — Accessible explainers.
+
+## Articles
+
+- [Lilian Weng — LLM Survey](https://lilianweng.github.io/posts/2023-01-10-the-gen-ai-layer/) — Overview of the LLM stack.
+- [Chip Huyen — LLM Observability](https://huyenchip.com/) — Production considerations.
+- [Simon Willison — LLMs](https://simonwillison.net/series/llms/) — Practical LLM usage.
+
+## Books
+
+- **Build a Large Language Model (From Scratch)** by Sebastian Raschka — Implement an LLM step by step.
+- **AI Engineering** by Chip Huyen — Production ML and LLM systems.
+
+## Tools
+
+- [OpenAI Tokenizer](https://platform.openai.com/tokenizer) — See how text is tokenized.
+- [tiktoken](https://github.com/openai/tiktoken) — OpenAI's tokenizer library for Python.
+- [Claude API](https://docs.anthropic.com/en/api/getting-started) — Experiment with context and temperature.

package/modules/llm-fundamentals/walkthrough.md

@@ -0,0 +1,91 @@
+# How LLMs Work — Walkthrough
+
+## Step 1: Tokenization — Breaking Text into Pieces
+
+Before an LLM can process your text, it splits it into tokens — subword units that the model understands.
+
+**Task:** Go to the OpenAI Tokenizer (https://platform.openai.com/tokenizer) or think manually: how would the sentence "I'm learning about tokenization" get split into tokens? Try splitting it yourself, then check.
+
+**Question:** Why do you think LLMs use subword tokens instead of whole words or individual characters? What trade-off does tokenization make?
+
+**Checkpoint:** The learner should understand that subword tokenization balances vocabulary size with coverage — common words get one token, rare words are split into pieces, and no word is ever "unknown."
+
+---
+
+## Step 2: Embeddings — From Tokens to Numbers
+
+<!-- hint:card type="concept" title="Embeddings" -->
+
+Tokens are discrete symbols. The model needs continuous numbers to compute with. Each token gets mapped to a high-dimensional vector called an embedding.
+
+**Task:** Consider the words "king", "queen", "man", "woman". If these are represented as vectors, what relationships would you expect between them? Sketch out (on paper or mentally) how you'd arrange them in 2D space.
+
+**Question:** The famous word2vec result is: king - man + woman ≈ queen. What does this tell you about what embeddings capture? Is it just spelling, or something deeper?
+
+**Checkpoint:** The learner should understand that embeddings encode semantic meaning — words with similar meanings have similar vectors, and relationships between words are preserved as directions in vector space.
+
+---
+
+## Step 3: Attention — The Core Mechanism
+
+<!-- hint:card type="concept" title="Attention" -->
+<!-- hint:diagram mermaid-type="flowchart" topic="transformer architecture" -->
+
+The transformer architecture's key innovation is the attention mechanism. It lets each token "look at" every other token to understand context.
+
+**Task:** Consider the sentence: "The bank by the river was steep." Now consider: "The bank approved my loan." The word "bank" appears in both. How would a model figure out which meaning is intended?
+
+**Question:** Why is attention described as letting tokens "attend to" each other? What would happen if a model could only see tokens in order (left to right) without attention?
+
+**Checkpoint:** The learner should understand that attention allows each token to weigh the relevance of all other tokens, resolving ambiguity based on context. Without attention, the model would struggle with long-range dependencies.
+
+---
+
+## Step 4: Context Windows — Memory Limits
+
+Every LLM has a maximum context window — the total number of tokens it can process at once (input + output). Claude's context window is 200K tokens; GPT-4 ranges from 8K to 128K.
+
+**Task:** Estimate: roughly how many pages of text fit in a 100K-token context window? (Hint: a typical page is ~300 words, and English averages ~1.3 tokens per word.)
+
+**Question:** If an LLM can only "see" what's in its context window, what happens when you ask about something mentioned 150K tokens ago in a long conversation? Does the model remember it the same way you would?
+
+**Checkpoint:** The learner should understand that LLMs have no persistent memory beyond the context window, that information early in a very long context may get less attention ("lost in the middle" phenomenon), and that ~100K tokens is roughly 250 pages.
+
+---
+
+## Step 5: Next-Token Prediction and Temperature
+
+LLMs generate text one token at a time by predicting the most probable next token given all previous tokens. The temperature parameter controls how "creative" the selection is.
+
+**Task:** Imagine the model is completing: "The capital of France is ___". At temperature 0, it always picks the highest-probability token. At temperature 1, it samples from the distribution. What output would you expect at each temperature?
+
+**Question:** If temperature 0 always picks the most likely token, why would you ever want higher temperature? What tasks benefit from predictability vs. creativity?
+
+**Checkpoint:** The learner should understand that temperature 0 gives deterministic, focused output (good for factual Q&A), higher temperatures introduce variety (good for creative writing), and very high temperatures produce incoherent text.
+
+---
+
+## Step 6: Why LLMs Hallucinate
+
+LLMs sometimes generate confident-sounding but incorrect information. This isn't a bug — it's a consequence of how they work.
+
+**Task:** Ask an LLM a very specific factual question about something obscure (e.g., "What was the population of a small town in 1987?"). Compare the answer to a verified source. Does the model hedge or state it confidently?
+
+**Question:** LLMs are fundamentally pattern-completion machines. Given that they predict the next most likely token, why would they generate false information with high confidence instead of saying "I don't know"?
+
+**Checkpoint:** The learner should understand that LLMs don't have a "knowledge" store they query — they complete patterns from training data. "I don't know" is rarely the most probable continuation, so the model defaults to plausible-sounding completions. RLHF helps but doesn't eliminate the problem.
+
+---
+
+## Step 7: Choosing the Right Model
+
+<!-- hint:buttons type="single" prompt="Which task needs a large model?" options="Classify tickets,Technical architecture,Short translation" -->
+<!-- hint:celebrate -->
+
+Different tasks call for different models. Larger models aren't always better — they're slower and more expensive.
+
+**Task:** You have three tasks: (1) classify customer support tickets into 5 categories, (2) write a detailed technical architecture document, (3) translate short phrases to Spanish. For each, would you choose a small/fast model or a large/powerful one? Why?
+
+**Question:** What factors should you consider when choosing a model besides raw capability? Think about latency, cost, context window, and task complexity.
+
+**Checkpoint:** The learner should understand the trade-offs: small models for simple/high-volume tasks (classification, extraction), large models for complex reasoning and generation, and that cost and latency matter as much as capability in production systems.

package/modules/one-on-ones/content.md

@@ -0,0 +1,133 @@
+# Effective 1:1s — Conversations That Build Trust and Growth
+
+<!-- hint:slides topic="1:1 meeting essentials: purpose, cadence, preparation, agenda structure, and anti-patterns" slides="5" -->
+
+## The Purpose of 1:1s
+
+A one-on-one is **their meeting, not yours**. Its purpose is to give your report space to talk about what matters to them: career growth, blockers, feedback, or just venting. When 1:1s become status reports or your agenda only, trust erodes and the meeting loses value.
+
+**Andy Grove** (High Output Management) argued that a manager's most valuable role is one-on-one time. **Camille Fournier** (The Manager's Path) emphasizes: the report should own the agenda. Your job is to listen, ask questions, and support.
+
+## Cadence: How Often?
+
+| Situation | Cadence | Why |
+|-----------|---------|-----|
+| New team member | Weekly | They need more guidance and relationship-building |
+| Established report | Biweekly | Enough rhythm without overwhelming |
+| Senior / highly autonomous | Biweekly or monthly | They self-manage; less frequent is fine |
+
+**Rule of thumb:** Never cancel 1:1s for "no urgent topics." The meeting *is* the relationship.
+
+## Preparation: The Shared Doc
+
+Use a **shared document** (Notion, Google Doc, etc.) that both you and your report can edit. The report adds topics before the meeting; you add yours. This:
+
+- Ensures nothing gets forgotten
+- Signals you take the meeting seriously
+- Gives you both time to think
+
+**Example doc structure:**
+
+```
+## Report's Topics
+- Want to discuss promotion timeline
+- Feedback on last week's presentation
+
+## Manager's Topics
+- Career check-in
+- Project X handoff
+
+## Notes (post-meeting)
+- Agreed to revisit promotion in 6 months with stretch goals
+```
+
+## Agenda Structure
+
+```mermaid
+flowchart TD
+    A[Start: Rapport check-in] --> B[Report's topics first]
+    B --> C[Manager's topics]
+    C --> D[Career / growth discussion]
+    D --> E[Action items + next 1:1 date]
+    E --> F[End]
+
+    style B fill:#3fb950
+    style C fill:#58a6ff
+```
+
+**Order matters:** Report's topics first. Their concerns, blockers, and ideas set the tone. Your topics (feedback, announcements) come second. Career and growth get dedicated time—don't rush them.
+
+## Types of Conversations
+
+| Type | What It Looks Like | Your Role |
+|------|-------------------|-----------|
+| **Career growth** | Goals, promotion, skills, stretch assignments | Ask questions; sponsor and advocate |
+| **Feedback** | Delivering or receiving feedback (use SBI) | Be specific; ask what support they need |
+| **Blockers** | Technical, interpersonal, or process | Help remove; don't solve for them |
+| **Coaching** | They're stuck; you help them think | Questions > answers; Socratic method |
+| **Venting** | Frustration, stress, team dynamics | Listen; don't fix; validate feelings |
+
+**Example — Coaching vs Fixing:** They say "I'm stuck on the API design." Instead of "Here's how I'd do it," try: "What have you tried? What's blocking you? What would success look like?"
+
+## Asking Good Questions
+
+- **Open-ended:** "What's on your mind?" "What would make this week a success?"
+- **Follow-up:** "Tell me more." "What happened next?" "How did that feel?"
+- **Silence:** After asking, *wait*. Give them 3–5 seconds. They'll often fill it with the real answer.
+
+**Lara Hogan** recommends: "What's the best use of our time today?" as an opener—lets them steer.
+
+## Managing Up: 1:1s With Your Manager
+
+Your 1:1s with your manager are also *your* meeting. Prepare topics: wins to share, decisions you need, blockers, career asks. Don't show up empty-handed. Your manager benefits from your clarity.
+
+## Skip-Level 1:1s
+
+When you're a skip-level (manager of managers), periodic 1:1s with your reports' reports build trust and surface issues. Keep them lighter and less frequent (e.g., quarterly). Don't undermine your managers—frame it as "I want to hear from you directly."
+
+## Common Anti-Patterns
+
+| Anti-Pattern | Better Practice |
+|-------------|-----------------|
+| Status updates only | Use standups for status; 1:1s for growth, feedback, blockers |
+| Cancelling frequently | 1:1s are sacrosanct; reschedule, don't cancel |
+| Only when things go wrong | Regular cadence builds trust; crisis-only = anxiety |
+| Manager does all the talking | Report's topics first; 70% them, 30% you |
+| No preparation | Shared doc; both add topics before meeting |
+| Rushing through | Block 30–60 min; don't squeeze between back-to-backs |
+
+## 1:1 Meeting Flow
+
+```mermaid
+flowchart LR
+    subgraph Prep["Before"]
+        P1[Report adds topics]
+        P2[Manager adds topics]
+    end
+
+    subgraph Meeting["During"]
+        M1[Rapport — 2 min]
+        M2[Report's topics — 15 min]
+        M3[Manager's topics — 10 min]
+        M4[Career / growth — 8 min]
+        M5[Action items — 5 min]
+    end
+
+    subgraph After["After"]
+        A1[Update shared doc]
+        A2[Schedule next 1:1]
+    end
+
+    P1 --> M1
+    P2 --> M1
+    M5 --> A1
+    A1 --> A2
+```
+
+## Quick Tips
+
+1. **Same time, same day** — Predictability helps both of you protect the slot.
+2. **Camera on (remote)** — Builds connection; treat it like an in-person conversation.
+3. **Take notes** — In the shared doc; you'll forget commitments otherwise.
+4. **Follow up** — If you said you'd do something, do it. Trust compounds.
+5. **Adjust over time** — As the relationship matures, adapt cadence and structure.