Lessons

How-tos

One job. One product. Do it, then check it. A How-to is a Lesson, not a wiki article. Leftover SNK3 Lessons are in this catalog.

• Claude Tag in Slack — watch the unasked post

  Possibility first: you can watch one real Slack thread and turn off Respond automatically if Claude wrote when nobody asked. This is a send-gate in the channel, not a caution lecture about bots at work.

• Microsoft 365 Copilot Coaching in Outlook — use one, leave one

  Possibility first: you can open Coaching on a draft you already own, use one suggestion, leave one unused, confirm it is still a draft, then you send. Apply-all is the fail. This is not Microsoft 365 Copilot Cowork.

• Microsoft 365 Copilot Notebooks — confirm names in the file

  Possibility first: you can drop a file you already have, ask for decisions and owners, then open that same file and confirm every name before the list leaves. The notebook list is not the source.

• Superhuman Go — check the underline, then send

  Possibility first: you can write a short update with a date and a number, leave Knowledge Checker on, and name a source for each underline before you send. The underline is a prompt to check, not a green light.

• Neural net layers — start at 2:25 (not the beginning)

  A neural layer is not a database of facts — it is a weighted mix of inputs passed through a simple function. Look for that picture of stacking layers.

• What 'learning' means — jump to 7:40 in the same film

  “Learning” here means adjusting weights so simple pieces stack into useful behavior — not magic download of knowledge.

• Self-attention in plain English — land at 34:20 (with context)

  Self-attention means each word/token can look at other words in the same message to decide what matters — the core move behind modern chat models. You do not need the full lecture to use that idea.

• Prediction engine vs database (with AI, not a essay)

  Chat models predict plausible text; they do not look up your private company database unless tools are deliberately connected.

• Hallucination — spot it in 60 seconds

  A hallucination is confident, fluent falsehood (fake case, book, section). Spot it; do not trust confidence as proof.

• Force bullets — constraint prompting

  Hard constraints (exactly N bullets, format, must/must-not) steer models better than polite-but-vague requests.

• No salaries in free public chat

  Never put salaries or other sensitive employee data into free public chat tools without an approved path.

• NotebookLM as a sidekick (Tim priority)

  NotebookLM is strongest when answers stay grounded in sources you gave it — not free-floating invention.

• One Anthropic Fluency idea — click is the content

  One clear idea from a short official unit beats “go take the whole course.” Extract one usable sentence.

• Prompt injection — spot it (no essay)

  Prompt injection hijacks the model with hidden or pasted instructions — learn to spot the tell phrases.

• Prompt injection round 2 — harder

  Harder injections hide in “notes” and documents; treat untrusted text as untrusted prompts.

• Excerpt: few-shot (we serve the meat)

  Few-shot means show the style you want with examples, then ask for one more in that pattern.

• Draft then human send

  AI drafts; humans own send. Edit before anything leaves to a client or boss.

• Is this AI? — three real systems

  AI is not only chatbots — spam filters, recommenders, and predictors count. Name the pattern.

• Context limits — we give you the long text

  Long context has limits; models may invent when the answer is not actually in the text you provided.

• Verify a claim (we supply the claim)

  Verification is a skill: check claims against a primary source, not against model confidence.

• Parameters without math fear

  Parameters are adjustable knobs that change behavior; you do not need the calculus to use the idea.

• Iterate once — draft then critique

  Pros iterate: draft → critique → revise once beats one-shot perfectionism.

• Board numbers — structure only

  AI may structure a board pack; it must not invent metrics. Humans own numbers and sources.

• Minimum necessary data — with a sample

  Minimum necessary data: share only what the task needs. Strip SSNs and extras before paste.

• Goal → draft → done-when (one loop)

  A tiny loop (goal → draft → done-when) turns AI from chat toy into a checkable work unit.

• Microsoft Learn — one unit only (Introduction 3 min)

  One short Microsoft Learn unit is enough for a snack — walk away with one sentence, not a certificate binge.

• Hugging Face — one page only

  One HF page, one idea. Optional docs live behind deeper links, not the daily unit.

• Simon prompt injection article — high value handoff

  Simon’s injection write-up: untrusted content can contain instructions. True/false that risk.

• Dragon motivation (with explicit AI window)

  Motivation snacks still use an AI window — finish with a checkable list, not a vague pep talk.

• Excel comes later — foundation first

  Excel/tool integrations come after foundations. Sequence skills; do not skip to advanced glue.

• Kaggle as closer only — one idea excerpted

  Kaggle-scale work is a closer, not a daily snack. One idea only.

• Spell out prompt engineering (no PE)

  Say “prompt engineering” in plain words: role, task, format, constraints — not unexplained “PE.”

• Podcast clip idea — we pick the episode

  Podcasts can be snacks if we name the clip/idea; never “go find a podcast.”

• Co-intelligence idea without signup trap

  Co-intelligence = clear human/AI roles. Name who decides and who drafts.

• Chrome Ask Gemini — where it lives

  Know where Chrome Ask Gemini (or your chat) lives so “do this now” is one click, not a scavenger hunt.

• Token — one definition with a model

  Tokens are pieces models process — not always whole words. Use that when length/limits confuse you.

• Temperature idea without lab gear

  Temperature-style settings trade creativity vs predictability — higher is freer, lower is safer.

• Skill tracking teaser (how Conehead will personalize)

  Conehead will personalize by demonstrated skills, not vibes. Completion checks feed that graph.

• Completion standards — what 'done' means

  “Done” must be checkable (MC, yes/no, count, artifact) — feelings are not a completion standard.

• One more mid-video practice — 3B1B at 12:00

  Practice mid-video deep links: land at a timestamp, take one idea, leave — marathons are optional.

• Refuse dry scavenger hunts

  Refuse scavenger-hunt content: one click must open the actual unit or full excerpt on the card.

• Recipe rolodex — AI window explicit

  Build a small personal recipe card set in an AI chat — reusable prompts you own.

• Conehead standard — snacks feed the climb

  Snacks feed the climb; courses are optional deeper. Daily unit stays short and checkable.

• X snack: tool loops beat one-shot chat (Anthropic talk seed)

  Stop only one-shot prompting: a small tool loop (goal → draft → critique → re-run once) beats a single clever line — use it in chat tools you already have.

• X snack: prompt vs tool-agent vs multi-step — pick the mode

  Separate one-shot chat, a tool-using agent product, and multi-step modes so you pick the lightest tool that still finishes the job.

• Name the agent pattern — most are not full autonomy

  “Agent” is not one product: name the pattern (assistant, tool-caller, watcher, etc.) so risk and cost match the job.

• X snack: CLAUDE.md / project memory beats one clever prompt

  Standing project memory (CLAUDE.md / rules file) beats reinventing the perfect prompt every session.

• X snack: Claude Skills guide signal (reuse expertise)

  Reusable “skills” package expertise so you do not re-explain the same workflow each time.

• X snack: force clarifying questions first

  Force clarifying questions first when the task is ambiguous — ambiguity kills quality.

• X snack: meeting notes → decisions / actions / opens

  Meeting notes become useful when forced into decisions / actions / open questions — not a transcript dump.

• X snack: cost of endless agent loops

  Endless agent loops have a cost (tokens, time, error). Budget steps; stop criteria matter.

• Split research, draft, and review — even in one chat

  Do not let one AI pass invent the numbers it later “validates.” Separate research, draft, and review steps.

• X snack: stop living only in the chat window

  Mastery leaves the chat window: files, checklists, and real deliverables — not only conversation.

• X-style: verify before you trust a thread

  Viral threads need steelman + verify before trust. Authority is earned by checks, not likes.

• X-style: screenshot prompts are still prompts

  Screenshots and images are still prompts — hidden text can instruct the model. Ask clarifiers.

• X-style: AIDA sales email with constraints

  Sales copy (AIDA) can use AI if constraints ban fake stats and human owns send.

• X-style: assumptions audit

  Assumptions audit: list what you (and the model) assumed before acting on a plan.

• X-style: Excel formula debug via chat

  Debug Excel formulas in chat with the formula + error + sample cells — still verify the fix in the sheet.

• X-style: evaluator-optimizer loop in plain English

  Evaluator-optimizer: score a draft against criteria, then rewrite once. That is a mini quality loop.

• X-style: routing — hard tickets vs easy

  Routing: classify hard vs easy work so simple tasks stay cheap and hard ones get humans/tools.

• X-style: prompt chaining with a gate

  Prompt chaining with a gate: each step has a check before the next step runs.

• X-style: parallel opinions then merge

  Parallel opinions then merge — and reject unsafe or invented consensus.

• X-style: human manages workflow not every keystroke

  Humans manage the workflow (gates, send, risk); they do not need to type every keystroke.

• X-style: memory vs secrets

  Memory helps continuity; secrets do not belong in memory. Draw the line explicitly.

• X-style: production guardrails keywords

  Production agents need named guardrails (auth, spend, human send, logging) — not vibes.

• Prefer a simple AI chat chain before you turn on 'agent' mode

  For routine work, a short prompt chain with a human check often beats flipping on full agent/autonomy settings — add tools only when the simple path fails.

• X-style: bookmark ≠ mastery

  Bookmarking is not mastery. Prove the idea with a tiny quiz or do-this-now.

• X-style: extract the quote, ignore the guru

  Extract the claim; ignore guru worship. Translate hype quotes into a checkable tool-use habit you can run today.

• X-style: tools save work — pick one pattern

  Pick one agent/tool pattern you can teach a coworker — menus of patterns are noise until one sticks.

• X-style: agent that emails — blast radius

  If an agent can send email, blast radius is real — last step must be human send.

• X-style: NotebookLM meets the feed

  Bring feed ideas into NotebookLM (or grounded tools) so answers cite sources, not hype.

• X-style: hype filter for 'beats any paid course'

  Hype phrases (“beats any paid course”) → rewrite as a falsifiable claim before you believe them.

• X-style: build a tiny self-prompt loop today

  Run Goal → Draft → Critique → Revise once today. That is a baby system that prompts itself.

• X snack: Grok screen share — AI that sees your work in real time

  Screen-share AI can see your work live — powerful for coaching, dangerous if secrets are on screen.

• X follow-up: screen share hygiene checklist

  Pre-flight before screen share: close password managers, hide PII, human still owns send/deploy.

• YouTube snack: Claude Cowork mobile — land at 0:47

  Mobile Cowork/chat is for portable assist — still not a free pass for work secrets on a phone.

• Mobile AI hygiene — same rules, smaller screen

  Phone AI feels casual; lock screen, no client PII in free apps, human reviews before send.

• X snack: systems that re-prompt themselves

  One-shot prompts lose to tiny loops: Goal → Draft → Critique → Revise.

• X snack: screen-share AI sees your desktop

  If AI can see your screen, the screen is the prompt — close secrets first.

• X snack: hosted SaaS vs private path (architecture)

  Hosted chat means data leaves your building unless tools/policies say otherwise.

• When a tool loops: remember what failed, fix, re-run once

  A useful AI work loop is not more prompt flair — remember what failed, apply one fix, re-run with a human stop. That is tool use with memory, not a platform you must build.

• Live screen context vs pasted screenshots

  Screen share gives continuous visual context — powerful for coaching, wasteful if a 1-line paste would do.

• ReAct loops vs marketing 'loops'

  When someone says 'agent loops,' check whether they mean the plain ReAct cycle (act → observe → act) or a product buzzword.

• Frontier models can exploit — do not hand-wave

  Dismissing real exploit demos as 'marketing' is unsafe — treat them as capability evidence and raise guardrails.

• Voice ramble → cleaner mind meld

  When you under-specify intent, a messy long ramble (voice or typed) can give the model more bits — then use its clean echo as the working brief.

• Constrain tools before a long AI session

  Before a long chat/agent session, set tool limits (domain allowlists, disable image/video gen, date cutoffs) so capability is not permission.

• Scheduled tool-calls vs a product labeled 'agent'

  A product labeled 'agent' may just be a scheduled prompt that calls tools toward a goal — test for schedule + tools + goal + human gate, not branding.

• Model 'self-awareness' is laggy pattern-match

  When a model talks about itself, treat it as incomplete pattern completion from training talk — useful sometimes, not a private inner life.

• Name the multi-step shape before you chain AI tools

  When a task needs more than one AI step, pick a simple shape—serial, parallel-then-merge, branch, or bounded loop—so you know where you stop and check the result.

• Prompt vs tool-agent vs multi-step — test the labels on tools you use

  Marketing says non-agentic / agent / agentic — verify on the product you use: tools? multi-step goal? memory/feedback? If none, it is still a chat tool.

• Benchmarks lag real tool work — test the skill you need

  Cute single-shot demos can detach from real workplace AI use: multi-turn tool calling on your actual tasks. Measure what your job needs, not the viral benchmark.

• Multipolar frontier — judge models by your eval, not the logo

  When many labs ship near the frontier at once, loyalty to one brand is weak strategy — pick by checkable evals on your tasks (tools, multi-step, cost).

• Chat → publish is not a free pass

  Describe-and-deploy AI tools make shipping a link trivial — still run secrets, domain, and human-gate checks before anything is public.

• AI tool value = checkable work shipped, not chat volume

  When a team claims an AI tool 'works,' ask what checkable work shipped (PRs merged, tickets closed, docs published) — not how many chats or prompts were sent.

• Start with a free short agent-product lesson — then prove it

  A short free lesson can define agent-labeled products for using tools at work — then you still must run one checkable task yourself.

• AI inside Docs/Sheets is still a send risk

  Workspace add-ons put models where you already work — powerful, and easy to leak client data if share/send is still human-owned only in theory.

• Keep AI out of your real browser profile

  AI-enhanced browsers inherit your logged-in sessions — prefer a separate browser profile for AI browsing tools so passwords and work tabs are not the tool surface.

• Same UI ≠ same model — check the product model id

  When a product swaps the model behind the same chat/agent UI, re-run your smoke checks — yesterday's quality and cost no longer apply.

• Use Copilot inside the app — stop paste-exporting work files

  When your org has Microsoft 365 Copilot or Google Workspace AI, draft and summarize inside Word/Docs/Excel/Sheets so work files stay in the approved tool — not pasted into a consumer chat.

• Image AI at work: brand-safe prompt + human publish gate

  Treat image/voice generators like any workplace tool: clear brief, no client faces or confidential UI, and a human gate before the asset ships.

• Voice mode is still a chat log — scrub before you speak

  Dictation and voice-to-AI still create transcripts your org or vendor may store — treat spoken prompts like typed ones: no client names, salaries, passwords, or unreleased numbers.

• Pick the approved AI chat first — then open a tab

  Before you paste work into any chat, open the tool your org approved (tenant ChatGPT/Claude/Gemini/Copilot) so policy and retention match the job — personal consumer accounts are last resort and never for client data.

• Phone AI chat is still work chat — lock the screen and the paste

  Mobile AI apps (ChatGPT/Claude/Gemini/Copilot on phone) get the same work data as desktop — use the org-approved app, disable lock-screen widget previews for sensitive drafts, and never dictate client names on a train.

• Voice vs dictation — and stop before purchase

  Dictation only turns speech into a one-shot prompt. ChatGPT Voice is an ongoing work conversation that can use screen and connected apps — and you still own send and spend.

• AI revenue brief — verify before you Slack the team

  Suite AI can merge CRM, calls, and market signals into a leadership brief — treat the report as a draft. Dig into cited claims, then human-own any Slack or priority change.

• Ask the sheet AI for a formula — then check one cell

  When Copilot/Gemini in Excel or Sheets writes a formula, treat it as a draft: spot-check one cell with a known answer before you trust the column.

• Deck AI drafts slides — you still own the story and the send

  Use Copilot/Gemini in PowerPoint or Slides for outline and layout drafts, then rewrite the narrative yourself and never auto-share client numbers.

• Email AI can draft — you still own the To line and Send

  Use Outlook/Gmail AI for reply drafts and tone, but verify recipients, attachments, and facts before Send — never auto-send client or HR mail.

• Meeting-summary AI is a draft — fix names before you share

  Teams/Meet/Zoom AI summaries invent attendees and action items — edit the summary before you paste it into Slack, email, or the CRM.

• Calendar AI can draft the invite — you still own Send

  Outlook/Google calendar copilots will propose times and fill attendees from a chat prompt — treat every invite as a draft until you verify who, when, and the body before Send.

• Teams chat AI catch-up is a draft — verify before you act

  Copilot “summarize what I missed” in Teams chat is a skim aid, not ground truth — check names, decisions, and links before you reply, commit, or escalate.

• Notion AI drafts pages — you still own the share link

  Notion AI can summarize, rewrite, and fill a page in seconds — treat every AI edit as a draft until you check facts and who the share link reaches.

• AI search cites sources — open one before you trust the answer

  Web-grounded AI (Copilot Search, Gemini, Perplexity-style tools) can invent calm-sounding facts — treat citations as the real product and open at least one source before you act or share.

• Doc AI summary is a skim — check the one claim you will use

  Copilot (or Gemini) document summarize is a map, not the territory — before you brief someone or act, open the source and verify the one number, name, or decision you will rely on.

• Public translators are not a secure vault for client text

  Free public translation tools are fine for public-safe wording — never paste client names, contracts, or credentials; use org-approved translate when the content is work-sensitive.

• Code copilot drafts — you still own the review before merge

  GitHub Copilot / IDE AI can write the patch in seconds — treat every suggestion as untrusted draft until you understand it and run your checks. Merge is a human gate.

• PDF / reader AI is a skim — verify the one number you will use

  Doc/PDF AI summaries and extractions are drafts. Before you file, quote, or decide, open the source page and verify the one number or claim you will act on.

• CRM / sales AI can draft — you still own the customer send

  CRM and sales AI can draft emails, next steps, and activity notes in seconds. Treat every outbound as untrusted until you check the contact, facts, and tone — send is a human gate.

• Hand one overnight job to a teammate bot

  Grok Bot is an always-on teammate with its own cloud computer. The skill is one bounded job plus a human approval gate — not watching a demo, and not building an agent platform.

• Give a bot the job — then shut the laptop

  A teammate bot is working when you can leave. The skill is assigning one finished-work job, closing the lid, and inspecting the output later — not watching the demo video all the way through.

• Switch Copilot to Grok 4.6 on one real file

  Grok 4.6 is now a model you can pick inside GitHub Copilot — CLI, IDE, and cloud. The skill is choosing it for one file you already own, then judging the patch yourself before merge.

• Run Grok 4.6 once in Build or Cursor

  Grok 4.6 shipped 12 August as a model you can run in Grok Build and Cursor — not only in Copilot. The skill is one owned task in the harness you already use, then inspect before you publish.

• Desktop AI sidekicks see your screen — treat capture as a paste

  Always-on desktop AI helpers that read the screen or clipboard are a continuous paste surface. Before you enable capture, decide what must never appear on screen.

• Custom instructions — set your defaults once

  Standing custom instructions (tone, role, format defaults) improve every future chat; one-off prompts only fix today's.

• Ask for a table — structured output beats prose

  Asking for output as a table with named columns makes AI answers easier to scan, compare, and paste into real tools.

• Give it a role AND an audience

  Naming who the model is and who the output is for changes vocabulary, depth, and tone more than any other single instruction.

• Context first, question second

  Pasting relevant background before the question dramatically improves answer quality — models can't read your mind, only your paste.

• Ask for three options, not one answer

  Requesting multiple distinct options with tradeoffs turns the model from oracle into idea generator — and keeps judgment human.

• Say what NOT to do — negative constraints work

  Explicit must-nots (no hype words, no invented stats, no preamble) shape output as much as positive instructions.

• Regenerate vs rewrite — fix the prompt, not the dice

  If two regenerations both miss, the prompt is the problem: edit the instructions rather than rerolling.

• Long doc Q&A — anchor your questions

  Asking section-anchored questions about a long document beats 'summarize this' for accuracy and checkability.

• Job posting _ interview questions in 5 minutes

  AI turns any job description into structured interview questions fast — humans still calibrate for fairness and fit.

• Rewrite for a reading level

  Asking for a specific reading level (grade 8, ESL-friendly) makes internal communications dramatically more usable.

• Bullet notes _ status update

  Rough bullets in, polished status update out — the human adds accuracy, the model adds structure.

• Brainstorm 20, keep 3

  Volume-then-filter beats asking for the single best idea — generate wide with AI, converge with human judgment.

• Summarize the policy for a new hire

  Explain this policy to someone on day one' produces summaries people actually read — verify against the source before sharing.

• Draft the hard email — bad news without blame

  AI drafts difficult messages (deadline slip, decline, pushback) in a neutral tone; the human owns facts, empathy check, and send.

• Messy process _ checklist

  Pasting a rambling process description and asking for a numbered checklist with owners converts tribal knowledge into usable ops.

• Translate jargon for executives

  Rewrite for a busy executive: decision needed, cost, risk, one recommendation' is a reusable template for upward communication.

• Ask what would change its answer

  State your confidence and what evidence would change this answer' exposes weak reasoning better than accepting fluent output.

• Cross-check one fact across two models

  Asking two different models the same factual question and comparing answers is a fast, free reliability check.

• Spot the invented citation

  Models fabricate plausible-looking references; every citation must be opened before it's repeated.

• Ask when its knowledge ends

  Every model has a training cutoff; recent events need web-grounded tools or human sources.

• Classify before you paste — 60-second drill

  Public / internal / confidential is the classification that decides where text may go; run it before every paste.

• Find the training toggle

  Consumer AI tools have settings controlling whether your chats train future models; know where yours is set.

• Redaction patterns that keep prompts useful

  Consistent placeholders (Client A, Project Blue, [AMOUNT]) preserve AI usefulness while stripping identifying data.

• Upload vs paste — where does the file go?

  Uploading a file sends the whole file, not just what you meant; scan for hidden tabs, comments, and metadata first.

• Free vs paid — what the upgrade actually buys

  Paid AI tiers typically buy better models, longer context, and file/tool features — decide by task, not hype.

• One task, two tools, pick a winner

  A 10-minute same-task bake-off on your real work beats any review article for choosing tools.

• Know your approved list — before you need it

  Most orgs have an approved-AI-tools list (or an implicit one); knowing it before the deadline crunch prevents policy accidents.

• When NOT to use AI at all

  Some tasks — final legal wording, personnel decisions, anything you can't verify — are wrong for AI regardless of tool quality.

• Save your best prompts — template beats memory

  A saved prompt template with blanks (audience, length, constraints) turns one good result into a repeatable one.

• Team prompt library — one shared doc

  A shared doc of five proven prompts with use-when notes spreads AI capability across a team faster than any training.

• Define done-when before you prompt

  Writing the acceptance criteria before prompting turns AI sessions from wandering chats into checkable work units.

• Friday five minutes — which AI habit stuck

  A weekly five-minute review (what worked, what flopped, one experiment for next week) compounds AI skills faster than courses.

• Automation charter — one job, limits, stop

  Before automating anything with AI, write the charter: the job, the inputs it may touch, the limits, and the stop condition.

• Week one: propose, never execute

  New automations should run in propose-only mode first — outputs reviewed by a human — before earning execution rights.

• The audit trail habit

  Logging what an automation did (when, what, result) is the difference between a controlled system and a mystery.

• Find the kill switch first

  Before relying on any automation, know exactly how to stop it in under a minute — pause, revoke, or unplug.

• Package one workflow as a custom assistant

  Custom GPTs / Claude Projects / Gems let you package instructions plus reference files into a reusable assistant — no code required.

• No-code intake: form in, summary out

  Chaining a form to an AI summarize step is the smallest real AI application — and teaches the full build loop.

• API key hygiene — the three rules

  Keys never go in shared prompts or client code, get rotated when exposed, and get scoped to least privilege.

• Prototype, pilot, production — three gates

  AI features graduate through gates: prototype (works for you), pilot (friendly users plus feedback), production (guardrails, owner, rollback).

• The one-page team AI policy

  A usable team policy fits one page: approved tools, banned data, verification rule, disclosure norm, who to ask.

• Run a 30-minute show-and-tell

  A monthly 'show your AI win' half-hour spreads working practice faster than mandated training.

• Measure outcomes, not logins

  AI adoption metrics that matter count verified work shipped (hours saved, drafts used, errors caught), not seat activations.

• Disclosure norms — when to say AI helped

  Teams need an explicit norm for when AI assistance is disclosed (external docs, analysis, code) versus assumed (drafts, formatting).