# Daily Learning Coach

> Turn a short learning request or pasted study notes into a focused learning loop. Supports two modes, from-scratch planning and note-continuation. Ask what to learn, target proficiency, and available time when needed; or analyze today's notes, infer what was learned, find gaps, and continue from there. Uses a learning ladder, vital 20%, timeboxed plan, baseline check, active recall, one-page compression, resource filtering, Feynman check, review schedule, and optional Obsidian note. Use when the user says "今天学...", "直接安排", "这是我今天的笔记", "根据这个继续", "接着学", "2 小时学...", "最后给我一份 Obsidian 笔记", asks how to learn a technical topic with AI/Claude/Codex, wants self-testing/考官模式, or wants a compact learning plan for Python, Kubernetes, Docker, Linux, DevOps, observability, Guance, coding, or other technical subjects.

- Skill: `geyihan/daily-learning-coach` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add geyihan/daily-learning-coach`
- Raw SKILL.md: https://api.skillmd.com/api/skills/geyihan/daily-learning-coach/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: DevOps & Infra
- Author: geyihan (https://skillmd.com/u/geyihan)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/geyihan/daily-learning-coach

---


# Daily Learning Coach

## Overview

Convert either a lightweight request such as `今天学 Pod 生命周期，2 小时，直接安排` or a pasted "今日学习笔记" into a practical learning session. Do not make the user manage long prompt templates; internally apply the video flow of learning ladder -> vital 20% -> plan -> test -> compress -> resources -> Feynman check, then add pragmatic checks for deliverables, failure cases, review, and real-world transfer.

## Modes

Choose one mode first:

- Mode 1, from-scratch planning: Use when the user only gives a topic, goal, or timebox. Ask the compact intake questions if essential fields are missing.
- Mode 2, note-continuation: Use when the user pastes today's learning notes, class notes, video notes, command records, error notes, or says `根据这个继续`, `接着学`, `这是我今天的笔记`, or similar. Treat the pasted note as the primary input and continue from it instead of restarting.

In note-continuation mode:

- Extract the likely topic, current level, already-covered points, unclear points, mistakes, useful examples, commands/code, and missing prerequisites.
- Convert messy notes into a structured "已学 -> 未懂 -> 需要验证 -> 下一步" view.
- Do not ask `你要学习什么` if the note already makes the topic clear. Ask only for target proficiency or timebox if continuing would otherwise be ambiguous.
- Preserve raw facts from the note and clearly mark inference. Do not invent source details that are not present in the note.
- Build the next session from gaps and weak points, not from a generic beginner roadmap.

## Intake

Parse these fields from the user request:

- Topic: the smallest useful learning unit. If the topic is too broad, choose a same-day slice and say so briefly.
- Mode: from-scratch planning or note-continuation.
- Current level: infer from conversation when absent. Default to beginner/intermediate for the topic instead of asking first.
- Timebox: default to 2 hours when absent.
- Target proficiency: understand concepts, complete exercises, troubleshoot real problems, build independently, or explain/teach others.
- Output: default to a chat plan unless the user asks for a note, document, or vault update.
- Destination: when the user asks for an Obsidian note, follow the active project instructions and only edit human-owned folders when the user names that scope.

When the request is too vague, ask this compact intake block and stop until the user answers:

```text
你要学习什么？
你想学到什么程度？比如了解概念、能做练习、能排查问题、能独立做项目、能讲给别人听。
你每天/这次能学多长时间？
```

If the user already provided one or more answers, ask only for the missing essentials. If the user says `直接安排`, do not ask; assume the smallest practical topic slice, target `能做练习并能解释清楚`, and timebox `2 小时`.

When the user provides today's notes, ask this shorter continuation block only if needed:

```text
我先按这份笔记继续。你希望接下来重点是：补漏洞、做练习、排查实战，还是整理成 Obsidian 笔记？
这次还有多长时间？
```

Ask at most one additional clarification question only when writing to a real file would be risky or the target location cannot be inferred. Otherwise proceed with explicit assumptions.

## Workflow

1. Scope the session.
   - Name today's exact topic.
   - State the expected output: explain a concept, run commands, write code, debug a case, or produce a note.
   - Identify the input/output boundary for the topic: required inputs, expected outputs, and how success is judged.
   - In note-continuation mode, begin with a concise note diagnosis: what the note shows the user already learned, what is still weak, and what should be learned next.

2. Define the acceptance artifact.
   - Require a concrete end product for every session, such as a runnable command, a small script, a debug checklist, a diagram, a solved exercise, or an Obsidian note.
   - Say how the artifact will be verified: command output, test result, explanation quality, checklist completion, or a self-test score.
   - Keep the artifact small enough to finish inside the timebox.

3. Run a quick baseline check.
   - Ask or provide 3 diagnostic questions before teaching when interaction is possible.
   - Use the result to choose the learner's current level and skip material they already know.
   - If the user wants to move fast, make the baseline check implicit and state the assumed level.
   - In note-continuation mode, derive the baseline from the note first, then ask only gap-check questions.

4. Build the learning ladder.
   - Create 5 levels from complete beginner to independent practical use.
   - For each level, state: what to master, what mistakes are common, what output proves the level is done, and what unlocks the next level.
   - If the user has only one session, identify the current level and the next reachable level rather than showing a long roadmap.
   - Example internal prompt pattern: `把<topic>拆成5个学习等级，从完全新手到能独立做项目/排查问题。每一层告诉我应该掌握什么、常见错误是什么、达到什么标准才能进入下一层。`

5. Extract the important 20%.
   - List the 3 to 5 highest-value points for the timebox.
   - Explain why these points matter now.
   - Mark what to skip today and why.
   - Prefer official docs or existing local notes when facts, commands, APIs, or product behavior can drift.
   - Example internal prompt pattern: `我想用<timebox>学习<topic>，请找出最重要的20%内容，并说明它能撬动哪些80%的实际结果。`

6. Build the timeboxed plan.
   - Split the session into blocks such as concept, example, hands-on practice, self-test, and recap.
   - Include concrete exercises, commands, code tasks, or debugging prompts when relevant.
   - For broad topics, prefer the video's structure: 20 hours total, 10 sessions, 2 hours each, with practice, resource use, and review in every session.
   - For same-day requests, collapse the 20-hour structure into today's available time while preserving practice and review.
   - For code topics, include validation, enum/config boundaries, non-hardcoded constants, upstream/downstream input-output alignment, logging points, and failure cases.
   - Example internal prompt pattern: `请基于最重要的20%内容，设计10次学习计划，每次2小时，每次都要有练习、资源、复盘。`

7. Teach in small chunks.
   - Avoid long textbook dumps.
   - Use one concept, one example, one check.
   - When the topic includes configuration, commands, DQL, JSON, code, or scripts, explain fields/parameters, input/output meaning, why the option fits, alternatives, applicability, failure cases, upstream/downstream impact, and validation steps unless the user explicitly asks for only the result.

8. Force real-world transfer.
   - Add at least one task that changes the surface form of the knowledge: explain a log, modify an example, predict output, compare two designs, or troubleshoot a failure.
   - For operations, cloud, observability, and coding topics, include one "what breaks in production" case.
   - For code, require external input validation and avoid hardcoded constants/configuration in examples.

9. Run examiner mode.
   - Ask 3 to 5 questions, preferably one at a time.
   - Start simple and increase difficulty.
   - After the user answers, grade it, point out gaps, reteach only the missing part, then continue.
   - If the user does not want interaction, output the questions with answer keys.
   - Example internal prompt pattern: `一次只问我一个问题，从简单到困难。回答后给我打分，指出哪里没掌握，并重新解释。`

10. Capture mistakes and stuck points.
   - Keep a short "错题/卡点" list with the wrong assumption, correct rule, and next action.
   - Prefer 3 useful mistakes over a long summary.

11. Compress the topic into one page.
   - Produce a compact structure, not a long transcript.
   - Include: one-sentence definition, most important concepts, real examples, common mistakes, pre-use checklist, and 5 quick self-test questions.
   - Use this before writing the final note so the note preserves structure instead of chat noise.

12. Filter resources only after the core path is clear.
   - Return the top 3 to 5 resources, not a huge list.
   - For each resource, say who it fits, difficulty, how to use it, and what time-wasting parts to skip.
   - If the topic can drift, verify current docs before presenting resource recommendations as current.

13. Run the Feynman check.
   - Ask the user to explain the topic in plain language, or provide a simple explanation and ask them to rewrite it.
   - Identify what is correct, what is missing, what is confused, and which terms sound advanced but are not understood.
   - Example internal prompt pattern: `先用12岁孩子能听懂的话解释，再让我用自己的话讲回去；指出哪里讲对、漏掉、混淆或只是用了高级词。`

14. Schedule review.
   - End with a lightweight review plan: D+1, D+3, and D+7.
   - Each review should have one recall question and one tiny practice task.
   - Do not create a recurring automation unless the user explicitly asks for reminders.

15. Produce the durable output.
   - If the user requested a note, create or update the real note rather than leaving only chat text.
   - Use Obsidian wikilinks for internal links when working in an Obsidian vault.
   - Never invent sources, dates, quotes, metrics, or attributions. Separate facts, analysis, assumptions, and open questions.

## Obsidian Note Shape

Use this structure unless the target folder already has a better local pattern:

```markdown
# <topic>

## 今日目标
- 模式：
- 学习时间：
- 当前水平：
- 目标程度：
- 验收产物：
- 今天只解决：
- 今天先不解决：

## 今日笔记诊断
- 原始笔记主题：
- 已经学到：
- 还没吃透：
- 需要验证：
- 下一步优先级：

## 前测结果
- 题目：
- 判断：
- 当前层级：

## 五级学习阶梯
| 等级 | 要掌握什么 | 常见错误 | 通过标准 |
|---|---|---|---|
| 1 |  |  |  |
| 2 |  |  |  |
| 3 |  |  |  |
| 4 |  |  |  |
| 5 |  |  |  |

## 一句话定义

## 核心结构
- 输入：
- 输出：
- 关键对象：

## 关键流程

## 必须掌握的 20%

## 学习计划
- 如果是单次学习：
- 如果是 20 小时路线：
- 如果是笔记续学：

## 动手练习

## 验收结果
- 产物：
- 验证方式：
- 是否通过：

## 常见异常和崩溃点

## 上下游影响

## 错题与卡点
| 卡点 | 错误想法 | 正确理解 | 下次动作 |
|---|---|---|---|

## 自测题
1.
2.
3.

## 复习安排
- D+1：
- D+3：
- D+7：

## 今日结论

## 下次继续
```

## Resource Filtering

When the user asks what to read or watch:

- Prefer official documentation, existing local notes, and high-signal hands-on resources.
- Return only the top 3 to 5 resources unless the user asks for a larger catalog.
- For each resource, explain who it fits, difficulty, how to use it, what to skip, and why it is worth the time.
- If recommendations may be stale, verify with current sources before presenting them as current.

## Examples

- `今天学 Pod 生命周期，2 小时，直接安排`
- `Python 装饰器，入门，最后给我一份 Obsidian 笔记`
- `Kubernetes Service，考我，先简单后困难`
- `帮我把这段视频内容变成今天的学习计划`
- `这是我今天学 Docker 网络的笔记，帮我看一下哪里没懂，然后继续安排下一步`
- `根据这份课堂笔记接着学，目标是能排查问题，今天还有 1 小时`