Reading Docs & Effective Googling — the Meta-Skill

Review boundary and corrected contracts

Match installed version, documentation and a minimal reproduction. Source is implementation evidence, not automatically the intended public contract. Removed fixed five-minute answer guarantees, automatic package installation and unsupported search-operator advice.

The examples below teach the stated input contracts; fragments and deliberately incorrect counterexamples are exercises, not production implementations. Complexity counts elementary operations unless a bit-cost or allocation caveat is stated. Practice times are suggestions, not measured performance or hiring guarantees.

Learning objective: Find a version-matched source, reproduce a claim and record uncertainty — using docs, source, and search queries that pros actually use.

Why this session exists

Finding an answer means narrowing a question, identifying the relevant version and configuration, and checking the result. Search, documentation, source and colleagues contribute different evidence. Speed improves with practice, but a fast answer is not necessarily a correct or supported one.

You will be able to

• Read a man page top-to-bottom and know which section is worth your time (SYNOPSIS, EXAMPLES, EXIT STATUS).

• Craft search queries with engine-supported operators to narrow candidates, then verify the answer against its governing version and context.

• Navigate a stranger's GitHub repo — README → docs/ → src/ → tests/ — and trace a public entry point to its implementation, recording the tag/commit and any unresolved layer.

• Use --help, tldr, cheat, and zeal/Dash offline docs to look up flags locally, distinguishing installed-version manuals from cached community examples.

• Investigate version/configuration mismatches and distinguish a documentation defect from an implementation regression.

Prerequisites

• S001 — Dev Environment · a working shell
• S002 — Git & GitHub · you'll clone repos to search their source
• S003 — The Command Line · grep/rg for searching source

Pre-read · skim before the session (25 min total)

Further reading: Getting Answers

Further reading: Dan Luu: programming doesn’t need math?

Further reading: How to ask a technical question

(a) Intuition · 5 min

Documentation is a library, not a novel

Real: You don't read a library. You walk in with a specific question, find the aisle, pull one book, flip to the index, read three paragraphs, and leave. Trying to read the whole reference is a beginner mistake — the same beginner mistake as trying to memorise a dictionary before speaking a new language. Every senior engineer treats docs the same way: skim the table of contents, scan for the section that matches your question, and read only what you need.

 
    Concretely: Diátaxis distinguishes four documentation needs; real sites may mix or omit those page types — Diátaxis calls them tutorials, how-to guides, reference, and explanation. Knowing which kind you need reduces irrelevant reading; no fixed lookup-time guarantee follows.
    Search queries are the same. A precise query can reduce irrelevant results, but ranking, indexing and terminology still matter. Inspect candidate sources rather than treating result count as correctness.
  

The four kinds of doc pages (Diátaxis)

Match your question to the right page shape

• Tutorials — ‘let me build my first X, step by step’. Good for guided learning; revisit when learning a new workflow or major version.

• How-to guides — ‘I have a specific problem, show me the recipe’. Reach for these when you already know the tool but need to do a specific thing.

• Reference — ‘what are the exact parameters of function foo?’ Organized by API surface. It may be handwritten or generated; read parameters, constraints and version changes.

• Explanation — ‘WHY does this tool work this way?’ Revisit when you need design rationale or a deeper model, not just during onboarding.

The most common mistake beginners make with docs

Beginners read tutorials when they need reference. They spend 45 minutes following a getting-started guide when their real question was "what does the --depth flag do?" — a 10-second reference lookup. Ask yourself: what page shape do I need? Then jump straight there.

A quick history of ‘how devs found answers’

Local manuals, web search, community Q&A, indexed source and generated suggestions coexist. Each changes the discovery route, not the need to verify a claim. Local manuals can match an installed binary; web docs may default to a newer release; indexed source may cover only a default branch; an LLM may invent a plausible API. This is the useful historical progression, not a claim that one new tool eliminated the older support channels.

(b) Turning a question into a source-backed answer · 15 min

The doc-hunting funnel

More ways to find answers also means more ways to lose time. Use the concrete question about npm ci to decide when to stay with a source and when to move on to the next one.

Use the diagram as one possible sequence, not a measured speed ranking. Ask a teammate early for incidents, access constraints or organization-specific context; use the public reference for support guarantees and source for implementation questions. A search/LLM suggestion can provide vocabulary, but verify it before relying on it.

Anatomy of a man page (worth memorising)

Sections of man \<tool> in the order you should read them

Name: NAME

Desc: One-line summary. Tells you if you're on the right page. Skim.

Name: SYNOPSIS

Desc: The command-line form. Square brackets commonly mark optional syntax; italics or angle brackets may denote placeholders, not literal text to type. Read that manual’s conventions.

Name: DESCRIPTION

Desc: Semantics, constraints and qualifications that examples may omit. Read the part governing your intended use.

Name: OPTIONS

Desc: Every flag. less-search with /--flag.

Name: EXAMPLES

Desc: Examples illustrate selected cases. Check their assumptions against SYNOPSIS, OPTIONS and DESCRIPTION before copying.

Name: EXIT STATUS

Desc: What non-zero codes mean. Useful in scripts.

Name: SEE ALSO

Desc: Cross-references. How you discover the tool you didn't know existed.

Google query operators and engine-specific limits

Name: Precision operators

Tagline: Cut noise from the top of results

• "exact phrase" — request an exact phrase; inspect the actual page and context

• site:docs.python.org — only that domain

• -term excludes a term; -site:example.com can narrow away a domain on Google

• after:2023-01-01 requests a date filter; it does not prove the page describes your installed version

• filetype:pdf — for papers and books

Name: Bad query

Tagline: ‘why is my python slow’

• Unspecified Python version and workload

• No error message or measured symptom

• Candidates may discuss unrelated performance problems

Name: Good query

Tagline: Same question, senior form

• ‘cpython list append amortized site:docs.python.org’

• ‘python 3.12 gil release notes’

• ‘"async def" pattern for i/o-bound site:realpython.com’

• Candidate pages with specific terminology; no guaranteed count, ranking or correctness

GitHub Code Search — the underrated superpower

Basic phrase

Desc: Use an escaped quoted query, such as "raise RuntimeError(\"loop already running\")", to look for that literal source text. It will not find every dynamically constructed message or every repository.

Narrow by language

Desc: language:python "asyncio.get_event_loop()" — only python files.

Narrow by repo

Desc: repo:torvalds/linux "panic(" — only inside the Linux kernel.

Narrow by path

Desc: path:tests/ "parametrize" — only test files.

Symbol search

Desc: symbol:parse_url language:python requests indexed definitions, not references; language/symbol coverage is incomplete.

Clone + rg

Desc: In an authorized local checkout, select the required tag/commit and search its files. A shallow default-branch clone may omit the release you need. Cloning transfers data and source inspection is not permission to run installation hooks.

The mental model to hold

Docs describe intent. Source describes reality.

When documentation and source disagree, first check the version and configuration. Source explains observed behavior; documented public contracts express support expectations. A minimal reproduction and issue history help distinguish a regression from intended behavior.

Myth: "Reading docs is the slow path. Searching gets me an answer in 30 seconds and copying a working Stack Overflow answer is the same thing as understanding it."

Truth: Search gives you an instance; docs give you the space. A search result answers the question you managed to phrase; the reference tells you which questions are askable at all — including the parameter that makes your whole workaround unnecessary.

Why: Because for the first year of a technology the tradeoff genuinely favours search. Common problems have been solved publicly, the top result usually works, and reading a reference page costs ten minutes to answer a one-minute question. What that habit hides is the failure mode that arrives later: you cannot search for a feature whose name you do not know. Engineers who only ever search end up reimplementing things that already existed as a flag — hand-rolled retry loops next to a built-in retries=, manual chunking next to a chunksize= parameter, a custom backfill next to an idempotent upsert mode. The search worked perfectly every time; it just never told them what they were missing.

Test: Inspect a standard-library API without installing a package or contacting a service:

import inspect
import json
import sys
 
print(sys.version.split()[0])
print(inspect.signature(json.loads))
print(json.loads('{"value": 1.25}', parse_float=str))
# {'value': '1.25'}: the supplied hook changes float decoding.

Looking at the signature reveals hooks you might not have searched for; the version-matched reference defines them. Counting parameters is not a measure of competence. For an already-installed third-party package, also record its version before using help() or inspecting its source.

For the original pandas variant, only if pandas is already installed in your intended environment, inspect the actual package and callable rather than installing a second version for this exercise:

import pandas as pd, inspect
sig = inspect.signature(pd.read_csv)
print(len(sig.parameters))
print(list(sig.parameters)[:20])
print(pd.__version__)
help(pd.read_csv)

This preserves the library-specific signature/version inspection example. It is not executed by this review; pandas import can load native extensions, and the number or order of parameters varies by version.

Question: Why does a reference often organize information differently from a task-focused blog post, and what does each provide?

Premise: A reference aims to describe the public API and supported behavior, but documentation can be incomplete or defective.

Because: anything omitted from the contract is something users will rely on and maintainers will break

Premise: Completeness forces the text to be organised by API surface — module, class, parameter — not by the tasks a reader has in mind.

Because: there are finitely many parameters but unbounded many tasks; only one of those can be enumerated

Premise: A tutorial or blog post has the opposite constraint: it optimises for one task, so it may omit everything irrelevant to that task, including the caveats.

Because: narrative flow requires cutting the 95% of the API the reader doesn't need right now

Premise: But a blog post is a snapshot taken on a date, against a version, by someone with no obligation to update it. A reference may be generated or handwritten, and its selected version may differ from the version you run.

Because: colocating documentation with source helps maintenance but does not ensure accuracy or version alignment

Conclusion: Use a tutorial to learn a workflow and the reference to check the supported contract. Read Notes, Warnings and Changed-in-version sections. If the source or a minimal reproduction disagrees, record the exact versions and configuration, look for an issue or changelog entry, and do not automatically declare either the documentation or implementation correct. A public implementation detail is not necessarily a stable API.

Name: Four doors: tutorial, how-to, reference, explanation

Picture: Every documentation set answers four different questions, and almost all frustration comes from knocking on the wrong door. Tutorial: I am new, teach me. How-to: I have a specific goal, give me steps. Reference: I need the exact contract. Explanation: I want to know why it was designed this way.Before reading anything, name which of the four you actually need. "The docs are bad" is usually "I opened the reference wanting a how-to."

• Stuck on how → how-to or a search. Stuck on what exactly → reference. Stuck on why is it like this → design docs, changelogs, GitHub issues, PEPs/RFCs.

• Always pin the version. Doc sites may default to latest; check rather than assume it matches your installation.

• When the docs run out, the source is documentation: inspect.getsource, the tests directory, and the issue tracker. Tests provide examples of expected behavior for the tested cases, not an exhaustive specification.

• Search queries should carry the error verbatim plus the library and version, and should exclude your own identifiers — those are unique to you and poison the results.

Trigger: Fire this model the moment you see: a third contradictory Stack Overflow answer · a snippet that fails with "unexpected keyword argument" · "the docs don't explain this" · an LLM answer using an API that does not exist · behaviour that differs between your laptop and prod.

Decision: You are blocked on an unfamiliar library. Do you search, read the reference, read the source, or ask a human?

Name: Search / LLM first

Gain: seconds to a candidate answer, and excellent for common well-trodden errors where thousands of people hit the same wall

Cost: answers are undated and unversioned; LLMs confidently hallucinate plausible parameter names; you learn the fix without learning the model, so the next variant blocks you again

Pick: the error message is generic, the library is popular, and you can verify the answer cheaply in under a minute

Name: Read the reference / source

Gain: evidence of the supported API and its implementation when you select the right version; reading adjacent contracts can explain related cases.

Cost: 10–60 minutes, and high up-front cost when you don't yet know the vocabulary to navigate it

Pick: you will touch this library more than twice, or the failure is in production, or search has already given you two contradictory answers

Name: Ask a human

Gain: gets you the unwritten context — the internal quirk, the known-bad version, the reason the team stopped using that path

Cost: spends someone else's focus, is asynchronous, and produces knowledge that stays in a DM instead of in a doc

Pick: you have already spent a bounded amount of time (say 30 minutes), and the problem smells organisation-specific rather than library-specific

Verdict: Timebox search, then escalate to the reference — and always verify a searched answer against the docs before it reaches a code review. The senior habit is not "read everything"; it is noticing fast when search has stopped converging and switching sources instead of running the same query with different words.When you do ask a human, ask well: state what you tried, what you expected, what happened, and the version. That turns a 20-minute conversation into a 2-minute one, and it frequently answers the question while you are writing it down.

(c) Hands-on · 25 min

Work through this yourself, one command at a time. No script — the whole point is that you build the muscle memory. Save answers in a scratchpad.

# S004 · doc-hunting drills.
# Time yourself. Aim: each question in under 3 minutes.
 
# --- Drill 1: begin with matching local documentation ---
# Q1a) What does `curl -f` do? (find the exact wording)
curl --help all | grep -A1 -- '--fail'
# Q1b) What flag makes curl follow redirects? (search the man page)
man curl | less        # then type: /follow  (press n to jump next hit)
# Q1c) If already installed, tldr provides community examples, not the authoritative contract
# Optional: install community tools through your reviewed package manager.
tldr curl
tldr tar
tldr find
 
# --- Drill 2: official docs, right level ---
# Q2a) How do you type-annotate a dict-of-lists in Python?
#   → docs.python.org/3/library/typing.html — search for `dict[`
# Q2b) In npm, what is the difference between `install` and `ci`?
#   → docs.npmjs.com — look at the CLI Commands reference
# Q2c) What are the top-level fields of a Kubernetes Deployment YAML?
#   → kubernetes.io/docs/reference — look for the API Reference (NOT the tutorial)
 
# --- Drill 3: search a real repo like a pro ---
# Q3a) How does React implement useState internally?
#   → github.com/facebook/react — Code Search: `symbol:useState language:javascript path:packages/react/`
# Q3b) Which file in the Linux kernel handles the `sched_yield` syscall?
#   → github.com/torvalds/linux — Code Search: `symbol:sched_yield`
# Q3c) In pandas, where is the actual code for DataFrame.merge?
#   → clone locally, then:
#   git clone --depth=1 https://github.com/pandas-dev/pandas /tmp/pandas
#   rg -n "def merge" /tmp/pandas/pandas/core/frame.py | head -5
 
# --- Drill 4: craft a precise Google query ---
# Bad:  "python threading slow"
# Good: "PEP 703 optional GIL Python 3.13 site:python.org"
# Good: "sqlalchemy 2.0 select().where() vs filter_by site:docs.sqlalchemy.org"
# Bad:  "aws lambda cold start"
# Good: "aws lambda cold start provisioned concurrency site:aws.amazon.com after:2023"
 
# --- Drill 5: when the doc site is bad, use SO — filtered ---
# Bad:  "python decorator @property not working"
# Good: "python @property setter not called site:stackoverflow.com after:2022"
#   → A score or accepted-answer mark is a relevance clue, not proof; verify the version and reproduction.
 
# --- Drill 6: LLMs as first draft, source as ground truth ---
# Prompt an LLM for a design review of size-limited middleware, without pasting private bodies.
# Then: check Starlette/FastAPI versions, body-stream consumption and privacy limits.
# Rule: finding a symbol proves existence only; check signature, behavior and negative cases too.

Worked drill answers and verification boundaries

1. curl: -f/--fail makes many HTTP responses of 400 or above fail with status 22 and suppresses the response body; it is not a complete authentication-error detector. -L/--location follows redirects. Check the installed curl manual because newer options in the live online manual may not exist locally. Community tldr pages give examples; they do not override that manual.
2. Reference questions: on Python 3.9+, groups: dict[str, list[int]] = {"a": [1, 2]} annotates a dict of integer lists; annotations do not enforce runtime types. npm v11 ci requires an existing matching lockfile, fails on package/lock mismatch, removes an existing node_modules, and does not update package manifests/locks; it can still run lifecycle scripts and download dependencies. It is not run here. A Deployment manifest has apiVersion: apps/v1, kind: Deployment, metadata and spec; server responses also expose status. Its selector must match the Pod-template labels. Reading YAML is not applying it to a cluster.
3. Pinned source navigation: in React v19.2.0 ReactHooks.js, exported useState calls resolveDispatcher() then dispatcher.useState(initialState). Follow into packages/react-reconciler/src/ReactFiberHooks.js: mountState creates hook/queue state and a dispatch function; update handling follows the reducer path. A wrapper location alone does not explain the reconciler. In Linux v6.17, SYSCALL_DEFINE0(sched_yield) calls do_sched_yield() and returns zero; old examples may name another file. In pandas v2.3.3 frame.py, DataFrame.merge imports and delegates to pandas.core.reshape.merge.merge. These are source-reading results, not React rendering, kernel scheduling or pandas execution tests.
4. Search: "PEP 703" "Python-Version" site:peps.python.org leads to the proposal’s Python 3.13 target; it does not mean Python 3.12 removed the GIL. "select" "filter_by" site:docs.sqlalchemy.org/en/20/ narrows API/version context. A cloud query about provisioned concurrency needs current provider documentation and cost/region qualifications, not a guaranteed cold-start fix.
5. Community answer triage: "property" "setter" site:stackoverflow.com can discover vocabulary. Check a minimal class with a setter against the installed Python reference; an accepted/high-score answer can still target another version or a different descriptor use. Record an unresolved result instead of inventing a successful search outcome.
6. Middleware review: do not accept code merely because BaseHTTPMiddleware exists. Check whether it consumes the request stream before forwarding it, enforces limits on observed bytes rather than trusting Content-Length, and avoids logging sensitive bodies. Starlette documents context-variable propagation limits in BaseHTTPMiddleware; pure ASGI middleware is an alternative but still needs body/chunk/error tests. No middleware installation, request handling or cloud call is claimed here.

The anatomy of a good query

Why the ‘good’ queries above beat the ‘bad’ ones

Name: Specific version number

Desc: ‘python 3.12’ narrows results to modern behaviour. Older docs can be exactly right for an older release; version and configuration matter more than age alone.

Name: site: filter

Desc: Force the highest-authority source. site:docs.python.org selects an official domain; choose the matching version and governing passage.

Name: Named concept

Desc: ‘GIL removal’, ‘provisioned concurrency’ — canonical names surface official docs. Vague verbs (‘slow’, ‘not working’) match tutorials and rants.

Name: after: / date range

Desc: Use a date filter when the question is about a recent change; omit it when investigating an older supported release. Engine syntax and indexing behavior differ.

Name: Negative filters

Desc: A domain restriction such as site:docs.python.org is often more precise than a blacklist. If excluding a domain on Google, use -site:example.com; do not infer correctness from a publisher label alone.

What to observe

Drill 1 checks whether local help contains the option and matches your installed version. Drill 3 is where most devs discover GitHub Code Search — many never leave. Drill 4 should produce a better-defined question and a versioned source; result counts are not a quality score. Drill 6 catches LLM hallucinations before they land in your code. Verify. Always.

Goal: Answer three ‘I don't know that library’ questions in 15 minutes

Hint: Time yourself. If any takes >5 min, note where you got stuck and try a different tier of the funnel.

Pick a library you have never used (e.g. httpx, polars, pydantic). Answer these three, using only docs + source (no LLM):

1. How do you install it and what's the minimum viable ‘hello world’?
2. What is one non-obvious feature the docs are proud of? (look at the front page of the docs — they'll be shouting about it)
3. Where in the source is the main entry point implemented? (rg -n 'def __init__' src/ | head, or Code Search for symbol:<main class>)

Write the answers in a scratchpad. Bonus: do the same drill weekly for a month. You will feel a step-change in confidence.

Worked unfamiliar-library example: argparse

For a no-install version of the three-question drill, use Python 3.12’s standard-library argparse. It ships with Python, so there is no package-install step. The minimal program below parses one required name and prints a greeting; invoke it with Ada as an argument.

import argparse
 
parser = argparse.ArgumentParser(description="Greet one person")
parser.add_argument("name")
args = parser.parse_args()
print(f"Hello, {args.name}")

The expected output is Hello, Ada. With no name, it reports usage and exits with status 2. One useful feature is add_mutually_exclusive_group(required=True), which can require exactly one of two modes. In CPython v3.12.3 Lib/argparse.py, locate class ArgumentParser and its parse_args method; the method calls parse_known_args and rejects remaining unexpected arguments. The 3.12 argparse reference supplies the supported contract. This is a complete answered example; repeat with an unfamiliar third-party library later without installing it just to read its docs.

Six optional discovery tools

Consider the tool when it solves a concrete discovery problem

• tldr — community examples; check the installed command’s manual for exact behavior.

• ripgrep (rg) — recursive search with ignore rules by default; flags and semantics differ from grep, so use its name explicitly.

• fd — sane find replacement.

• bat — cat with syntax highlighting and git diff markers.

• zoxide — smarter cd; z proj jumps to any dir you've visited that contains ‘proj’.

• fzf — fuzzy finder. Bind to Ctrl-R for history search that will change your life.

(d) Production reality · 15 min

Three evidence failures. These are illustrative, not timed company incident reports. A storage-key mismatch is a contract question: record the exact string (including a leading slash) on both writer and reader and check the storage API, rather than assuming paths are normalized like a local filesystem. A plausible nonexistent API needs the version-matched public reference, not repeated guesses. Boto3’s documented get_object response contains a Body StreamingBody; botocore documents iter_chunks on that response object and close for its underlying stream. Calling an S3 client merely to introspect a name can trigger credential discovery; read the docs/source instead when you do not intend cloud access.

For a blocked support question, provide a minimal sanitized reproduction, exact versions/OS, expected behavior, actual output, and links to the passages you tried. Redact credentials, private URLs and personal data before sharing. During an incident escalate under the team’s process rather than waiting an arbitrary thirty-minute timer.

Where this shows up in the rest of the plan

Root: Reading docs and source is a skill every future session assumes

Label: S005–S011 · Python foundations

Desc: You'll reach for help(), ? in IPython, and the CPython source constantly.

Label: S045 · Pandas / Polars

Desc: Every DataFrame method has a subtle behaviour. Reading source > guessing.

Label: S056 · Docker

Desc: The Docker docs are excellent — treat them as your first hit.

Label: S060 · Linux fundamentals

Desc: man 2 read, man 7 signal — the OS reference is where you'll live.

Label: Further practice · Observability & SRE

Desc: Reading Prometheus / Grafana / OpenTelemetry docs is a daily task.

Label: Later sessions · Transformers & LLMs

Desc: Read papers for original claims and assumptions, using explanations and reproductions to check your understanding.

(e) Recall + stretch · 10 min

Self-check (answer follows each question).

Recall — questions and worked answers

Q: What are the four Diátaxis types of documentation, and which do you use most day-to-day?

A: Tutorials guide learning, how-to guides address a concrete goal, reference specifies API details, and explanation develops understanding. Choose by your current need; neither Diátaxis nor this review establishes an 80% time split or a rule to read explanation only once.

Q: Which section of a man page do you read first?

A: Start with NAME to confirm the tool and SYNOPSIS/OPTIONS for an exact flag question; use EXAMPLES for a workflow, then read governing qualifications in DESCRIPTION and EXIT STATUS. There is no universal first section or guaranteed nine-in-ten shortcut.

Q: Craft a Google query to find the exact behaviour of git rebase --autosquash — official docs only, no blog spam.

A: git rebase autosquash site:git-scm.com. Open the rebase manual for your Git version and read the autosquash conditions, not just a snippet. A domain filter narrows where results come from; it does not verify the result’s version.

Q: What's the difference between GitHub's Code Search and cloning + rg?

A: GitHub Code Search searches its index with repo/path/language/symbol qualifiers; it is not an exhaustive search of every branch/file on GitHub. Documented limits include default-branch coverage and incomplete symbol support. A local search covers the files present at your chosen checkout/ref; ignored/generated files and search flags still affect results. Neither approach proves absence without a coverage contract.

Q: You ask an LLM ‘what boto3 method streams an S3 object?’ and it answers download\_file\_stream(). What's the next thing you do?

A: Read the matching Boto3 S3 client reference and botocore response documentation without creating a credential-aware client. get_object returns a response whose Body is a StreamingBody; iter_chunks() belongs to that body. A name-existence check alone would not verify signature, permissions, retry behavior or stream lifetime. No AWS call or credential discovery is needed for this documentation check.

Q: You're evaluating a new library. Which three docs pages do you read first?

A: Read the README/front page for scope, the matching-version getting-started page for prerequisites and a minimal workflow, then concepts/architecture for the model. Consult the exact API reference for the operation you need; do not install or execute unfamiliar setup commands just to complete this reading exercise.

Q: Name three tools that let you get docs without a browser, and one use case for each.

A: (1) An already cached tldr <cmd> page provides community examples. (2) <cmd> --help or an installed man page documents local command usage. (3) Dash/Zeal can search downloaded docsets offline; verify the docset version. Initial cache/docset downloads still require network access.

Q: A tutorial and the source disagree about how a function behaves. Which one is correct?

A: Match the installed version first. Source explains observed implementation; the public reference describes intended supported behavior. A discrepancy may be a documentation bug or an implementation regression, so reproduce it before deciding what to rely on.

Q: You're on an open-source Slack asking a question that's been unanswered for 2 hours. What do you do?

A: Add a concise sanitized reproduction, versions, expected/actual results and relevant docs to the original thread rather than spamming duplicates. Use project escalation guidance for urgent incidents. Maintainers may not have time to answer; more context improves the question but does not guarantee a reply.

Q: Stretch — write the ‘search query taxonomy’ you'll use for the next month. Give one concrete query per type: (a) find a function's behaviour, (b) find who's affected by a recent bug, (c) find production usage of a library, (d) find the canonical doc page for a concept.

Stretch: true

A: (a) "asyncio.wait_for" timeout site:docs.python.org/3.12/ for behavior; (b) "psycopg2" "SSL SYSCALL error" site:github.com after:2024-01-01 as a candidate issue search, not a count of all affected users; (c) GitHub language:python "from httpx import" "AsyncClient" to find examples, then inspect whether each is production code or a test; (d) reconciliation site:react.dev for the conceptual documentation. Preserve version/source/context alongside the query; a code-search hit is not evidence that a deployment uses it.

Explain-out-loud test

If you can't teach these three without notes, redo the session:

1. What are the four Diátaxis types of docs? (name them, one sentence each)
2. What's the doc-hunting funnel? (list the six levels in order)
3. Why can't you trust an LLM's code without verifying? (one concrete failure mode)

Model answers: (1) Tutorial teaches, how-to solves a task, reference specifies, explanation develops the model. (2) One route is local help → official docs → source → web/community → LLM draft → human; reorder for incidents or local context. (3) A plausible download_file_stream call may not exist in the selected API; check the supported operation and response contract without initiating cloud credential discovery.

What comes next

Hub: The 6-Month Learning Plan

Part of a 130-session learning series. Suggested session: 70 minutes across the five labeled blocks, plus 20 minutes for setup, questions and retesting. Optional pre-reading is separate; these are pacing suggestions, not completion guarantees.

Corrective source notes

• typing — Support for type hints — Python 3.12 documentation — Python does not enforce ordinary function and variable annotations at runtime. Checked 2026-10-09.

Governing references: Diátaxis, Google operators, GitHub search syntax, GitHub search limits, curl manual, npm v11 ci, Deployment specification, Boto3 get_object, StreamingBody, and Starlette 0.48.0 middleware documentation.

These citations support the named claims, not blanket certification of the lesson. Worked proofs are derived in the text; execution scope and finite-test limits are recorded separately.