LLM Learning Path

Learning path

LLM Learning Path

From one-shot chatbot queries to Cursor-style IDE collaboration and OpenClaw-style local agent governance

This path is not a pile of isolated prompt tricks. It is a staged upgrade: first write clear requests, then collaborate with tools and a codebase, then design MCP, Skills, and safety boundaries for local agents.

Start learning GitHub

Learning path

Foundation: how LLMs work

这一段先解决什么： Before chasing techniques, start by understanding why models drift, miss details, or answer unevenly.

你会学到什么： This stage introduces tokens, context windows, modalities, and tool boundaries.

学完后你能做什么： After this stage you can tell whether a problem comes from the prompt, the context, or the task actually needing tools.

Stage 0: clear requests

这一段先解决什么： Many people start with one-shot chatbot questions and expect the model to fill in the missing background.

你会学到什么： This stage turns casual asks into clear briefs with goals, context, constraints, outputs, and acceptance checks.

学完后你能做什么： After this stage you can rewrite vague asks into clear tasks and know when clarification should come first.

Stage 1: tools & function calling

这一段先解决什么： Once a task touches schedules, databases, APIs, or code, chat alone stops being enough.

你会学到什么： This stage teaches the split between continuing the conversation and using systems, APIs, or actions.

学完后你能做什么： After this stage you can scope work the way you would with Cursor: files, actions, parameters, and validation.

Stage 2: MCP

这一段先解决什么： If you keep pasting documents and status updates into chat, it is usually a sign the workflow needs better wiring.

你会学到什么： This stage explains how files, knowledge bases, APIs, and permissions can be connected in a standard way.

学完后你能做什么： After this stage you can decide when MCP is worth it and define a small, safe integration shape.

Stage 3: Skills

这一段先解决什么： If you keep re-explaining the same task, it is time to capture that workflow instead of repeating it.

你会学到什么： This stage turns personal habits into reusable Skills / SOPs with inputs, steps, outputs, and failure handling.

学完后你能做什么： After this stage you can package your collaboration habits into instructions that teammates or agents can reuse.

Stage 4: Harness

这一段先解决什么： A prompt and a workflow are still not enough once real usage starts exposing drift and edge cases.

你会学到什么： This stage adds checklists, eval cases, regression sets, and human fallback where needed.

学完后你能做什么： After this stage you can design lightweight harnesses for important tasks and reason about rollout safety.

Cross-cutting tips

这一段先解决什么： By the time you reach local agents, the question is no longer just “can I use this?” but “can I govern this safely?”

你会学到什么： This stage connects safety boundaries, approvals, human responsibility, and long-term usage habits.

学完后你能做什么： After this stage you can build a durable workflow from one-shot chat to Cursor-style collaboration to OpenClaw-style agents.

All challenges

  1. What is an LLM (intuition)
  2. Tokens and context windows
  3. Modalities and tool boundaries
  4. Say what you need, clearly and precisely
  5. Hard constraints on long context
  6. Why one-shot queries get stuck
  7. The prompt brief kit: goal, context, constraints, output, acceptance
  8. When the model should ask questions first
  9. Rewrite a vague request into an executable brief
  10. Everyday requests that deserve tools
  11. Which tasks should not rely on chat alone
  12. Structured output is not the same as a real tool call
  13. Before Cursor, learn how to assign work to an IDE assistant
  14. Write an executable coding request for an IDE assistant
  15. What MCP is for
  16. Do we need MCP? A tiny checklist
  17. Why IDE collaboration is not enough
  18. MCP is about the right context, not just more context
  19. Write a minimal MCP integration spec for a knowledge base or API
  20. Skills — turn playbooks into executable specs
  21. Turn a repeating workflow into a Skill-style spec
  22. Prompt vs template vs Skill vs SOP
  23. Turn personal habits into agent-ready skills
  24. Write a skill spec for “read requirements -> edit code -> self-test -> report”
  25. Distinguish prompt, template, Skill, and playbook
  26. Harness engineering — tame nondeterminism
  27. A one-page acceptance checklist
  28. Why a Skill is still not enough
  29. From manual checks to a lightweight regression set
  30. Design a first regression set for a task
  31. Write a one-page “pre-launch checks + rollback on failure” rulebook
  32. Habits you can adopt today
  33. Local agent safety boundaries: files, commands, and secrets
  34. AI and my job — a three-part lens
  35. Which decisions should stay with humans
  36. Turn one-off usage into a long-term learning loop

Learning resources

Resources are grouped by the learning sequence: structured prompting first, then tools and IDE collaboration, then MCP, local agents, Skills, harnesses, and safety. On-site lessons are original; external links are mostly official docs.

From one-shot queries to structured prompts

From chat to tools / function calling

From IDE collaboration to code agents

  • Cursor docs

    Official docs for codebase-aware collaboration. Best after Stage 1 basics.

  • Cursor rules

    Helpful for understanding scoped collaboration, rules, and guardrails in an IDE.

  • Cursor guides

    Workflow-oriented docs for moving from prompts to codebase tasks.

MCP and local agents

Skills / playbooks / SOPs

Harness / evals / reliability

Safety, permissions, and governance