learn

name	learn
description	Use when a task depends on tech you don't actually know — an unfamiliar library, a fast-moving framework, a tricky API, an unfamiliar codebase — or whenever "I think it works like…" is load-bearing. Just-in-time and task-scoped; distinct from levelup, which updates the durable knowledge base.

MasterMind — Learn

The invokable form of ~/.mastermind/engineering/core/agent-loop.md → "Learn the stack before you build." Topic/task: $ARGUMENTS. Goal: reach genuine, current understanding — enough to build to standard — fast, and cheap on context.

1. Detect what's actually used

Read package.json/lockfile, configs, and representative source to see the exact stack (framework + versions, styling, state, data, test runner) and the team's conventions. Installed versions matter — APIs drift, so learn the version that's actually here.

2. Map the skill-tree

Use the relevant roadmap.sh role/topic map as the checklist of what matters and to spot your gaps. Learn just the branch the task touches; the rest of the tree waits.

3. Learn to current standards

Read the primary docs for the specific APIs the task needs (verify against the installed version) and skim one battle-tested example (the field's curriculum.md lists them). Prefer primary sources; read them fresh, since memory goes stale (the field's learning-sources.md).

4. Ground it in this codebase

Grep for how the pattern is already used here and match it. Consistency beats novelty.

5. Grill your assumptions before you build

The costly bugs come from unchecked assumptions. Before committing code:

• List what you believe about the APIs you'll use (behavior, signatures, return values, limits, versions, edge cases) — specifically ("getFile streams any size" — true?).
• Answer from the source yourself first — verify each against the docs/types/actual source (for the installed version). Confirm ✓, correct ✗, or mark unknown ❓. Anything the code/docs answer, you answer.
• For each remaining unknown, propose a resolution — a bare flag is half the job. State a best guess + confidence ("probably streams; ~70%") so a human can confirm or correct, not author it. Serve interdependent unknowns one at a time. Anything still unconfirmed becomes an explicit risk or a tiny spike — never a silent guess. No load-bearing assumption ships unverified.

Output & economy

Return a tight working brief: the stack + versions, the few APIs/patterns the task needs, the gotchas (and the grilled assumptions ledger: claim → verified/corrected/unknown → source · confidence), and links to the primary sources — not a tutorial. Delegate wide reading to a subagent to protect context. If you learned something durable and reusable, capture it via levelup.