[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-552":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":10,"totalLinesOfCode":10,"stars":12,"forks":13,"watchers":14,"openIssues":15,"contributorsCount":16,"subscribersCount":16,"size":16,"stars1d":17,"stars7d":18,"stars30d":19,"stars90d":16,"forks30d":16,"starsTrendScore":20,"compositeScore":21,"rankGlobal":10,"rankLanguage":10,"license":22,"archived":23,"fork":23,"defaultBranch":24,"hasWiki":25,"hasPages":23,"topics":26,"createdAt":10,"pushedAt":10,"updatedAt":37,"readmeContent":38,"aiSummary":39,"trendingCount":16,"starSnapshotCount":16,"syncStatus":40,"lastSyncTime":41,"discoverSource":42},552,"learn-claude-code","shareAI-lab\u002Flearn-claude-code","shareAI-lab","Bash is all you need -  A nano claude code–like 「agent harness」, built from 0 to 1","https:\u002F\u002Flearn.shareai.run",null,"Python",66085,10765,279,26,0,205,1386,6259,1058,45,"MIT License",false,"main",true,[27,28,29,30,31,32,33,34,35,36],"agent","agent-development","ai-agent","claude","claude-code","educational","llm","python","teaching","tutorial","2026-06-12 02:00:15","[English](.\u002FREADME.md) | [中文](.\u002FREADME-zh.md) | [日本語](.\u002FREADME-ja.md)\n# Learn Claude Code -- Harness Engineering for Real Agents\n\n## Agency Comes from the Model. An Agent Product = Model + Harness.\n\nBefore we talk about code, let's get one thing straight.\n\n**Agency -- the ability to perceive, reason, and act -- comes from model training, not from external code orchestration.** But a working agent product needs both the model and the harness. The model is the driver, the harness is the vehicle. This repo teaches you how to build the vehicle.\n\n### Where Agency Comes From\n\nAt the core of every agent is a neural network -- a Transformer, an RNN, a learned function -- that has been trained, through billions of gradient updates on action-sequence data, to perceive an environment, reason about goals, and take actions. Agency is never granted by the surrounding code. It is learned by the model during training.\n\nHumans are the best example. A biological neural network shaped by millions of years of evolutionary training, perceiving the world through senses, reasoning through a brain, acting through a body. When DeepMind, OpenAI, or Anthropic say \"agent,\" the core of what they mean is always the same thing: **a model that has learned to act, plus the infrastructure that lets it operate in a specific environment.**\n\nThe proof is written in history:\n\n- **2013 -- DeepMind DQN plays Atari.** A single neural network, receiving only raw pixels and game scores, learned to play 7 Atari 2600 games -- surpassing all prior algorithms and beating human experts on 3 of them. By 2015, the same architecture scaled to [49 games and matched professional human testers](https:\u002F\u002Fwww.nature.com\u002Farticles\u002Fnature14236), published in *Nature*. No game-specific rules. No decision trees. One model, learning from experience. That model was the agent.\n\n- **2019 -- OpenAI Five conquers Dota 2.** Five neural networks, having played [45,000 years of Dota 2](https:\u002F\u002Fopenai.com\u002Findex\u002Fopenai-five-defeats-dota-2-world-champions\u002F) against themselves in 10 months, defeated **OG** -- the reigning TI8 world champions -- 2-0 on a San Francisco livestream. In a subsequent public arena, the AI won 99.4% of 42,729 games against all comers. No scripted strategies. No meta-programmed team coordination. The models learned teamwork, tactics, and real-time adaptation entirely through self-play.\n\n- **2019 -- DeepMind AlphaStar masters StarCraft II.** AlphaStar [beat professional players 10-1](https:\u002F\u002Fdeepmind.google\u002Fblog\u002Falphastar-mastering-the-real-time-strategy-game-starcraft-ii\u002F) in a closed-door match, and later achieved [Grandmaster status](https:\u002F\u002Fwww.nature.com\u002Farticles\u002Fd41586-019-03298-6) on European servers -- top 0.15% of 90,000 players. A game with imperfect information, real-time decisions, and a combinatorial action space that dwarfs chess and Go. The agent? A model. Trained. Not scripted.\n\n- **2019 -- Tencent Jueyu dominates Honor of Kings.** Tencent AI Lab's \"Jueyu\" [defeated KPL professional players](https:\u002F\u002Fwww.jiemian.com\u002Farticle\u002F3371171.html) in a full 5v5 match at the World Champion Cup. In 1v1 mode, pros won only [1 out of 15 games and never survived past 8 minutes](https:\u002F\u002Fdeveloper.aliyun.com\u002Farticle\u002F851058). Training intensity: one day equaled 440 human years. By 2021, Jueyu surpassed KPL pros across the full hero pool. No handcrafted matchup tables. No scripted compositions. A model that learned the entire game from scratch through self-play.\n\n- **2024-2025 -- LLM agents reshape software engineering.** Claude, GPT, Gemini -- large language models trained on the entirety of human code and reasoning -- are deployed as coding agents. They read codebases, write implementations, debug failures, coordinate in teams. The architecture is identical to every agent before them: a trained model, placed in an environment, given tools to perceive and act. The only difference is the scale of what they've learned and the generality of the tasks they solve.\n\nEvery one of these milestones points to the same fact: **agency -- the ability to perceive, reason, and act -- is trained, not coded.** But every agent also needed an environment to operate in: the Atari emulator, the Dota 2 client, the StarCraft II engine, the IDE and terminal. The model provides intelligence. The environment provides the action space. Together they form a complete agent.\n\n### What an Agent Is NOT\n\nThe word \"agent\" has been hijacked by an entire cottage industry of prompt plumbing.\n\nDrag-and-drop workflow builders. No-code \"AI agent\" platforms. Prompt-chain orchestration libraries. They all share the same delusion: that wiring together LLM API calls with if-else branches, node graphs, and hardcoded routing logic constitutes \"building an agent.\"\n\nIt doesn't. What they build is a Rube Goldberg machine -- an over-engineered, brittle pipeline of procedural rules, with an LLM wedged in as a glorified text-completion node. That is not an agent. That is a shell script with delusions of grandeur.\n\n**Prompt plumbing \"agents\" are the fantasy of programmers who don't train models.** They attempt to brute-force intelligence by stacking procedural logic -- massive rule trees, node graphs, chain-of-prompt waterfalls -- and praying that enough glue code will somehow emergently produce autonomous behavior. It won't. You cannot engineer your way to agency. Agency is learned, not programmed.\n\nThose systems are dead on arrival: fragile, unscalable, fundamentally incapable of generalization. They are the modern resurrection of GOFAI (Good Old-Fashioned AI) -- the symbolic rule systems the field abandoned decades ago, now spray-painted with an LLM veneer. Different packaging, same dead end.\n\n### The Mind Shift: From \"Developing Agents\" to Developing Harness\n\nWhen someone says \"I'm developing an agent,\" they can only mean one of two things:\n\n**1. Training the model.** Adjusting weights through reinforcement learning, fine-tuning, RLHF, or other gradient-based methods. Collecting task-process data -- the actual sequences of perception, reasoning, and action in real domains -- and using it to shape the model's behavior. This is what DeepMind, OpenAI, Tencent AI Lab, and Anthropic do. This is agent development in the truest sense.\n\n**2. Building the harness.** Writing the code that gives the model an environment to operate in. This is what most of us do, and it is the focus of this repository.\n\nA harness is everything the agent needs to function in a specific domain:\n\n```\nHarness = Tools + Knowledge + Observation + Action Interfaces + Permissions\n\n    Tools:          file I\u002FO, shell, network, database, browser\n    Knowledge:      product docs, domain references, API specs, style guides\n    Observation:    git diff, error logs, browser state, sensor data\n    Action:         CLI commands, API calls, UI interactions\n    Permissions:    sandboxing, approval workflows, trust boundaries\n```\n\nThe model decides. The harness executes. The model reasons. The harness provides context. The model is the driver. The harness is the vehicle.\n\n**A coding agent's harness is its IDE, terminal, and filesystem access.** A farm agent's harness is its sensor array, irrigation controls, and weather data feeds. A hotel agent's harness is its booking system, guest communication channels, and facility management APIs. The agent -- the intelligence, the decision-maker -- is always the model. The harness changes per domain. The agent generalizes across them.\n\nThis repo teaches you to build vehicles. Vehicles for coding. But the design patterns generalize to any domain: farm management, hotel operations, manufacturing, logistics, healthcare, education, scientific research. Anywhere a task needs to be perceived, reasoned about, and acted upon -- an agent needs a harness.\n\n### What Harness Engineers Actually Do\n\nIf you are reading this repository, you are likely a harness engineer -- and that is a powerful thing to be. Here is your real job:\n\n- **Implement tools.** Give the agent hands. File read\u002Fwrite, shell execution, API calls, browser control, database queries. Each tool is an action the agent can take in its environment. Design them to be atomic, composable, and well-described.\n\n- **Curate knowledge.** Give the agent domain expertise. Product documentation, architectural decision records, style guides, regulatory requirements. Load them on-demand (s05), not upfront. The agent should know what's available and pull what it needs.\n\n- **Manage context.** Give the agent clean memory. Subagent isolation (s04) prevents noise from leaking. Context compression (s06) prevents history from overwhelming. Task systems (s07) persist goals beyond any single conversation.\n\n- **Control permissions.** Give the agent boundaries. Sandbox file access. Require approval for destructive operations. Enforce trust boundaries between the agent and external systems. This is where safety engineering meets harness engineering.\n\n- **Collect task-process data.** Every action sequence the agent executes in your harness is training signal. The perception-reasoning-action traces from real deployments are the raw material for fine-tuning the next generation of agent models. Your harness doesn't just serve the agent -- it can help improve the agent.\n\nYou are not writing the intelligence. You are building the world the intelligence inhabits. The quality of that world -- how clearly the agent can perceive, how precisely it can act, how rich its available knowledge is -- directly determines how effectively the intelligence can express itself.\n\n**Build great harnesses. The agent will do the rest.**\n\n### Why Claude Code -- A Masterclass in Harness Engineering\n\nWhy does this repository dissect Claude Code specifically?\n\nBecause Claude Code is the most elegant and fully-realized agent harness we have seen. Not because of any single clever trick, but because of what it *doesn't* do: it doesn't try to be the agent. It doesn't impose rigid workflows. It doesn't second-guess the model with elaborate decision trees. It provides the model with tools, knowledge, context management, and permission boundaries -- then gets out of the way.\n\nLook at what Claude Code actually is, stripped to its essence:\n\n```\nClaude Code = one agent loop\n            + tools (bash, read, write, edit, glob, grep, browser...)\n            + on-demand skill loading\n            + context compression\n            + subagent spawning\n            + task system with dependency graph\n            + team coordination with async mailboxes\n            + worktree isolation for parallel execution\n            + permission governance\n```\n\nThat's it. That's the entire architecture. Every component is a harness mechanism -- a piece of the world built for the agent to inhabit. The agent itself? It's Claude. A model. Trained by Anthropic on the full breadth of human reasoning and code. The harness doesn't make Claude smart. Claude is already smart. The harness gives Claude hands, eyes, and a workspace.\n\nThis is why Claude Code is the ideal teaching subject: **it demonstrates what happens when you trust the model and focus your engineering on the harness.** Every session in this repository (s01-s12) reverse-engineers one harness mechanism from Claude Code's architecture. By the end, you understand not just how Claude Code works, but the universal principles of harness engineering that apply to any agent in any domain.\n\nThe lesson is not \"copy Claude Code.\" The lesson is: **the best agent products are built by engineers who understand that their job is harness, not intelligence.**\n\n---\n\n## The Vision: Fill the Universe with Real Agents\n\nThis is not just about coding agents.\n\nEvery domain where humans perform complex, multi-step, judgment-intensive work is a domain where agents can operate -- given the right harness. The patterns in this repository are universal:\n\n```\nEstate management agent    = model + property sensors + maintenance tools + tenant comms\nAgricultural agent         = model + soil\u002Fweather data + irrigation controls + crop knowledge\nHotel operations agent     = model + booking system + guest channels + facility APIs\nMedical research agent     = model + literature search + lab instruments + protocol docs\nManufacturing agent        = model + production line sensors + quality controls + logistics\nEducation agent            = model + curriculum knowledge + student progress + assessment tools\n```\n\nThe loop is always the same. The tools change. The knowledge changes. The permissions change. The agent -- the model -- generalizes.\n\nEvery harness engineer reading this repository is learning patterns that apply far beyond software engineering. You are learning to build the infrastructure for an intelligent, automated future. Every well-designed harness deployed in a real domain is one more place where an agent can perceive, reason, and act.\n\nFirst we fill the workshops. Then the farms, the hospitals, the factories. Then the cities. Then the planet.\n\n**Bash is all you need. Real agents are all the universe needs.**\n\n---\n\n```\n                    THE AGENT PATTERN\n                    =================\n\n    User --> messages[] --> LLM --> response\n                                      |\n                            stop_reason == \"tool_use\"?\n                           \u002F                          \\\n                         yes                           no\n                          |                             |\n                    execute tools                    return text\n                    append results\n                    loop back -----------------> messages[]\n\n\n    That's the minimal loop. Every AI agent needs this loop.\n    The MODEL decides when to call tools and when to stop.\n    The CODE just executes what the model asks for.\n    This repo teaches you to build what surrounds this loop --\n    the harness that makes the agent effective in a specific domain.\n```\n\n**12 progressive sessions, from a simple loop to isolated autonomous execution.**\n**Each session adds one harness mechanism. Each mechanism has one motto.**\n\n> **s01**   *\"One loop & Bash is all you need\"* — one tool + one loop = an agent\n>\n> **s02**   *\"Adding a tool means adding one handler\"* — the loop stays the same; new tools register into the dispatch map\n>\n> **s03**   *\"An agent without a plan drifts\"* — list the steps first, then execute; completion doubles\n>\n> **s04**   *\"Break big tasks down; each subtask gets a clean context\"* — subagents use independent messages[], keeping the main conversation clean\n>\n> **s05**   *\"Load knowledge when you need it, not upfront\"* — inject via tool_result, not the system prompt\n>\n> **s06**   *\"Context will fill up; you need a way to make room\"* — three-layer compression strategy for infinite sessions\n>\n> **s07**   *\"Break big goals into small tasks, order them, persist to disk\"* — a file-based task graph with dependencies, laying the foundation for multi-agent collaboration\n>\n> **s08**   *\"Run slow operations in the background; the agent keeps thinking\"* — daemon threads run commands, inject notifications on completion\n>\n> **s09**   *\"When the task is too big for one, delegate to teammates\"* — persistent teammates + async mailboxes\n>\n> **s10**   *\"Teammates need shared communication rules\"* — one request-response pattern drives all negotiation\n>\n> **s11**   *\"Teammates scan the board and claim tasks themselves\"* — no need for the lead to assign each one\n>\n> **s12**   *\"Each works in its own directory, no interference\"* — tasks manage goals, worktrees manage directories, bound by ID\n\n---\n\n## The Core Pattern\n\n```python\ndef agent_loop(messages):\n    while True:\n        response = client.messages.create(\n            model=MODEL, system=SYSTEM,\n            messages=messages, tools=TOOLS,\n        )\n        messages.append({\"role\": \"assistant\",\n                         \"content\": response.content})\n\n        if response.stop_reason != \"tool_use\":\n            return\n\n        results = []\n        for block in response.content:\n            if block.type == \"tool_use\":\n                output = TOOL_HANDLERS[block.name](**block.input)\n                results.append({\n                    \"type\": \"tool_result\",\n                    \"tool_use_id\": block.id,\n                    \"content\": output,\n                })\n        messages.append({\"role\": \"user\", \"content\": results})\n```\n\nEvery session layers one harness mechanism on top of this loop -- without changing the loop itself. The loop belongs to the agent. The mechanisms belong to the harness.\n\n## Scope (Important)\n\nThis repository is a 0->1 learning project for harness engineering -- building the environment that surrounds an agent model.\nIt intentionally simplifies or omits several production mechanisms:\n\n- Full event\u002Fhook buses (for example PreToolUse, SessionStart\u002FEnd, ConfigChange).\n  s12 includes only a minimal append-only lifecycle event stream for teaching.\n- Rule-based permission governance and trust workflows\n- Session lifecycle controls (resume\u002Ffork) and advanced worktree lifecycle controls\n- Full MCP runtime details (transport\u002FOAuth\u002Fresource subscribe\u002Fpolling)\n\nTreat the team JSONL mailbox protocol in this repo as a teaching implementation, not a claim about any specific production internals.\n\n## Quick Start\n\n```sh\ngit clone https:\u002F\u002Fgithub.com\u002FshareAI-lab\u002Flearn-claude-code\ncd learn-claude-code\npip install -r requirements.txt\ncp .env.example .env   # Edit .env with your ANTHROPIC_API_KEY\n\npython agents\u002Fs01_agent_loop.py       # Start here\npython agents\u002Fs12_worktree_task_isolation.py  # Full progression endpoint\npython agents\u002Fs_full.py               # Capstone: all mechanisms combined\n```\n\n### Web Platform\n\nInteractive visualizations, step-through diagrams, source viewer, and documentation.\n\n```sh\ncd web && npm install && npm run dev   # http:\u002F\u002Flocalhost:3000\n```\n\n## Learning Path\n\n```\nPhase 1: THE LOOP                    Phase 2: PLANNING & KNOWLEDGE\n==================                   ==============================\ns01  The Agent Loop          [1]     s03  TodoWrite               [5]\n     while + stop_reason                  TodoManager + nag reminder\n     |                                    |\n     +-> s02  Tool Use            [4]     s04  Subagents            [5]\n              dispatch map: name->handler     fresh messages[] per child\n                                              |\n                                         s05  Skills               [5]\n                                              SKILL.md via tool_result\n                                              |\n                                         s06  Context Compact      [5]\n                                              3-layer compression\n\nPhase 3: PERSISTENCE                 Phase 4: TEAMS\n==================                   =====================\ns07  Tasks                   [8]     s09  Agent Teams             [9]\n     file-based CRUD + deps graph         teammates + JSONL mailboxes\n     |                                    |\ns08  Background Tasks        [6]     s10  Team Protocols          [12]\n     daemon threads + notify queue        shutdown + plan approval FSM\n                                          |\n                                     s11  Autonomous Agents       [14]\n                                          idle cycle + auto-claim\n                                     |\n                                     s12  Worktree Isolation      [16]\n                                          task coordination + optional isolated execution lanes\n\n                                     [N] = number of tools\n```\n\n## Architecture\n\n```\nlearn-claude-code\u002F\n|\n|-- agents\u002F                        # Python reference implementations (s01-s12 + s_full capstone)\n|-- docs\u002F{en,zh,ja}\u002F               # Mental-model-first documentation (3 languages)\n|-- web\u002F                           # Interactive learning platform (Next.js)\n|-- skills\u002F                        # Skill files for s05\n+-- .github\u002Fworkflows\u002Fci.yml      # CI: typecheck + build\n```\n\n## Documentation\n\nMental-model-first: problem, solution, ASCII diagram, minimal code.\nAvailable in [English](.\u002Fdocs\u002Fen\u002F) | [中文](.\u002Fdocs\u002Fzh\u002F) | [日本語](.\u002Fdocs\u002Fja\u002F).\n\n| Session | Topic | Motto |\n|---------|-------|-------|\n| [s01](.\u002Fdocs\u002Fen\u002Fs01-the-agent-loop.md) | The Agent Loop | *One loop & Bash is all you need* |\n| [s02](.\u002Fdocs\u002Fen\u002Fs02-tool-use.md) | Tool Use | *Adding a tool means adding one handler* |\n| [s03](.\u002Fdocs\u002Fen\u002Fs03-todo-write.md) | TodoWrite | *An agent without a plan drifts* |\n| [s04](.\u002Fdocs\u002Fen\u002Fs04-subagent.md) | Subagents | *Break big tasks down; each subtask gets a clean context* |\n| [s05](.\u002Fdocs\u002Fen\u002Fs05-skill-loading.md) | Skills | *Load knowledge when you need it, not upfront* |\n| [s06](.\u002Fdocs\u002Fen\u002Fs06-context-compact.md) | Context Compact | *Context will fill up; you need a way to make room* |\n| [s07](.\u002Fdocs\u002Fen\u002Fs07-task-system.md) | Tasks | *Break big goals into small tasks, order them, persist to disk* |\n| [s08](.\u002Fdocs\u002Fen\u002Fs08-background-tasks.md) | Background Tasks | *Run slow operations in the background; the agent keeps thinking* |\n| [s09](.\u002Fdocs\u002Fen\u002Fs09-agent-teams.md) | Agent Teams | *When the task is too big for one, delegate to teammates* |\n| [s10](.\u002Fdocs\u002Fen\u002Fs10-team-protocols.md) | Team Protocols | *Teammates need shared communication rules* |\n| [s11](.\u002Fdocs\u002Fen\u002Fs11-autonomous-agents.md) | Autonomous Agents | *Teammates scan the board and claim tasks themselves* |\n| [s12](.\u002Fdocs\u002Fen\u002Fs12-worktree-task-isolation.md) | Worktree + Task Isolation | *Each works in its own directory, no interference* |\n\n## What's Next -- from understanding to shipping\n\nAfter the 12 sessions you understand how harness engineering works inside out. Two ways to put that knowledge to work:\n\n### Kode Agent CLI -- Open-Source Coding Agent CLI\n\n> `npm i -g @shareai-lab\u002Fkode`\n\nSkill & LSP support, Windows-ready, pluggable with GLM \u002F MiniMax \u002F DeepSeek and other open models. Install and go.\n\nGitHub: **[shareAI-lab\u002FKode-cli](https:\u002F\u002Fgithub.com\u002FshareAI-lab\u002FKode-cli)**\n\n### Kode Agent SDK -- Embed Agent Capabilities in Your App\n\nThe official Claude Code Agent SDK communicates with a full CLI process under the hood -- each concurrent user means a separate terminal process. Kode SDK is a standalone library with no per-user process overhead, embeddable in backends, browser extensions, embedded devices, or any runtime.\n\nGitHub: **[shareAI-lab\u002FKode-agent-sdk](https:\u002F\u002Fgithub.com\u002FshareAI-lab\u002FKode-agent-sdk)**\n\n---\n\n## Sister Repo: from *on-demand sessions* to *always-on assistant*\n\nThe harness this repo teaches is **use-and-discard** -- open a terminal, give the agent a task, close when done, next session starts blank. That is the Claude Code model.\n\n[OpenClaw](https:\u002F\u002Fgithub.com\u002Fopenclaw\u002Fopenclaw) proved another possibility: on top of the same agent core, two harness mechanisms turn the agent from \"poke it to make it move\" into \"it wakes up every 30 seconds to look for work\":\n\n- **Heartbeat** -- every 30s the harness sends the agent a message to check if there is anything to do. Nothing? Go back to sleep. Something? Act immediately.\n- **Cron** -- the agent can schedule its own future tasks, executed automatically when the time comes.\n\nAdd multi-channel IM routing (WhatsApp \u002F Telegram \u002F Slack \u002F Discord, 13+ platforms), persistent context memory, and a Soul personality system, and the agent goes from a disposable tool to an always-on personal AI assistant.\n\n**[claw0](https:\u002F\u002Fgithub.com\u002FshareAI-lab\u002Fclaw0)** is our companion teaching repo that deconstructs these harness mechanisms from scratch:\n\n```\nclaw agent = agent core + heartbeat + cron + IM chat + memory + soul\n```\n\n```\nlearn-claude-code                   claw0\n(agent harness core:                (proactive always-on harness:\n loop, tools, planning,              heartbeat, cron, IM channels,\n teams, worktree isolation)          memory, soul personality)\n```\n\n## About\n\u003Cimg width=\"260\" src=\"https:\u002F\u002Fgithub.com\u002Fuser-attachments\u002Fassets\u002Ffe8b852b-97da-4061-a467-9694906b5edf\" \u002F>\u003Cbr>\n\nScan with WeChat to follow us,\nor follow on X: [shareAI-Lab](https:\u002F\u002Fx.com\u002Fbaicai003)\n\n## License\n\nMIT\n\n---\n\n**Agency comes from the model. The harness makes agency real. Build great harnesses. The model will do the rest.**\n\n**Bash is all you need. Real agents are all the universe needs.**\n","Learn Claude Code 是一个专注于构建AI代理框架的教学项目。该项目通过TypeScript语言实现，旨在教会开发者如何从零开始构建支持AI模型运行的“车辆”部分，即所谓的“harness”，以辅助模型在特定环境中有效运作。核心功能包括提供一系列教程和示例代码，帮助理解并实践如何为训练好的AI模型配备必要的执行环境。适用于希望深入了解AI代理开发流程、特别是对Claude等先进语言模型感兴趣的教育场景或个人学习目的。",2,"2026-06-11 02:37:22","top_all"]