# lintsinghua/claude-code-book

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/lintsinghua-claude-code-book).**

_How this analysis was created: the description and tags below were written by an AI model that read this project's README and public documentation pages; stars, license and language come straight from the GitHub API. The model does not read the source code._

4,359 stars · 847 forks · Python

## Links

- GitHub: https://github.com/lintsinghua/claude-code-book
- Homepage: https://lintsinghua.github.io
- awesome-repositories: https://awesome-repositories.com/repository/lintsinghua-claude-code-book.md

## Topics

`agent` `agent-architecture` `ai-agent` `anthropic` `book` `chinese` `claude-code` `llm` `mcp`

## Description

This repository is a long-form technical book about how a production AI coding agent runtime, often called an agent harness, is built. It dissects a real-world coding agent's architecture chapter by chapter and turns it into transferable lessons, and it also works as a step-by-step guide to designing and building your own harness around a language model. Python scripts in the repository support the book itself rather than the agent.

The book's core subject is the machinery around the model: a streaming conversation loop that repeats tool calls until the model returns plain text, a tool protocol whose safe defaults fail closed, and a staged permission pipeline in which deny rules always win. It then covers the topics that set a full harness apart from a simple API call. These include progressive context compression with a circuit breaker, long-term memory limited to a closed set of categories, layered configuration that excludes untrusted project settings, and forked sub-agents that share a cached prompt prefix. Coordinator-and-worker orchestration is covered alongside them.

Further chapters cover extension through lifecycle hooks, skills, plugins and external tool servers connected over the Model Context Protocol. They also cover plan-first workflows, scheduling and remote triggers, shell and file tool references, streaming and startup performance, and security boundaries such as enterprise policy controls and trust levels for skills.

For navigation, the book offers a guided reading path with suggested routes for different readers. Appendices provide a source-tree map, a complete tool inventory, a feature flag reference and a bilingual glossary. Helper scripts check the Markdown chapters and validate the embedded Mermaid diagrams, and others generate the cover and a star-history chart.

## Tags

### Artificial Intelligence & ML

- [Agent Harnesses](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-systems-frameworks/agent-capabilities-skills-tooling/agent-harnesses.md) — Teaches how the runtime harness around a language model fits together, from autocomplete assistants to autonomous coding agents, with design principles and a mental model. ([source](https://github.com/lintsinghua/claude-code-book#readme))
- [Long-term Memory Stores](https://awesome-repositories.com/f/artificial-intelligence-ml/agent-architectures/memory-management-systems/long-term-memory-stores.md) — Covers persistent agent memory with closed categories, an index file for recall, and a store-only-non-derivable rule that carries knowledge across sessions. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/README.md))
- [Agent Conversation Loops](https://awesome-repositories.com/f/artificial-intelligence-ml/agent-conversation-loops.md) — Run the main loop as an async generator that streams events, supports cancellation, and applies backpressure between the producer and the user interface consumer. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86-%E5%9F%BA%E7%A1%80%E7%AF%87/02-%E5%AF%B9%E8%AF%9D%E5%BE%AA%E7%8E%AF-Agent%E7%9A%84%E5%BF%83%E8%B7%B3.md))
- [Agentic Loop Design](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-loop-design.md) — Explains designing the core conversation loop as an async generator that emits events, handles termination reasons and injects dependencies for testing. ([source](https://github.com/lintsinghua/claude-code-book/tree/main/en))
- [Agentic Execution Loops](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-reasoning-loops/critic-agent-loops/agentic-execution-loops.md) — Details the streaming async-generator conversation loop that repeats tool calls until the model returns plain text, including termination reasons. ([source](https://github.com/lintsinghua/claude-code-book#readme))
- [Subagent Architectures](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-systems-frameworks/agent-orchestration-multi-agent/subagent-design/subagent-architectures.md) — Explains forking isolated subagents and delegating work to built-in explore and plan agents, with scheduled triggers for background tasks. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E9%99%84%E5%BD%95/C-%E5%8A%9F%E8%83%BD%E6%A0%87%E5%BF%97%E9%80%9F%E6%9F%A5%E8%A1%A8.md))
- [Context Compression](https://awesome-repositories.com/f/artificial-intelligence-ml/context-compression.md) — Applies progressively stronger context compression levels, from trimming to summarization and collapse, guarded by a circuit breaker to keep long conversations within limits. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/en/README.md))
- [Context Window Management](https://awesome-repositories.com/f/artificial-intelligence-ml/context-window-management.md) — Teaches computing the effective context window and applying staged compression guarded by a circuit breaker to keep long agent sessions within model limits. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/README.md))
- [Automatic Context Compaction](https://awesome-repositories.com/f/artificial-intelligence-ml/long-context-processing/automatic-context-compaction.md) — Escalates from light trimming and micro-compaction to summarization and full context collapse, guarded by a circuit breaker, to keep long conversations within the window.
- [Multi-Agent Orchestration](https://awesome-repositories.com/f/artificial-intelligence-ml/multi-agent-orchestration.md) — Explains how coordinator-worker architectures and forked sub-agents inherit context and split work into parallel sub-tasks. ([source](https://lintsinghua.github.io/))
- [Tool-Calling Agent Loops](https://awesome-repositories.com/f/artificial-intelligence-ml/tool-calling-agent-loops.md) — Implements a streaming generator loop that repeats model calls and tool execution until the model returns plain text, with cancellation support.
- [Hybrid Short-and-Long Term Memory](https://awesome-repositories.com/f/artificial-intelligence-ml/agent-architectures/memory-management-systems/long-term-memory-stores/hybrid-short-and-long-term-memory.md) — Covers index-backed long-term memory combined with multi-level context compression and a circuit breaker for keeping long agent sessions within limits. ([source](https://github.com/lintsinghua/claude-code-book/tree/main/en))
- [Closed Category Taxonomies](https://awesome-repositories.com/f/artificial-intelligence-ml/agent-architectures/memory-management-systems/long-term-memory-stores/long-term-memory-injection/hierarchical-memory-organization/closed-category-taxonomies.md) — Limits long-term memory to a closed set of types such as user, feedback, project, and reference, saving only information that cannot be derived. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E4%BA%8C%E9%83%A8%E5%88%86-%E6%A0%B8%E5%BF%83%E7%B3%BB%E7%BB%9F%E7%AF%87/06-%E8%AE%B0%E5%BF%86%E7%B3%BB%E7%BB%9F-Agent%E7%9A%84%E9%95%BF%E6%9C%9F%E8%AE%B0%E5%BF%86.md))
- [Sub-Agent Task Delegation](https://awesome-repositories.com/f/artificial-intelligence-ml/agent-delegation/sub-agent-task-delegation.md) — Spawns forked child agents that share the parent's cached prompt prefix, run in isolated state, and return results to a coordinator, with recursive forking blocked.
- [Agent Lifecycle Hooks](https://awesome-repositories.com/f/artificial-intelligence-ml/agent-lifecycle-hooks.md) — Describes lifecycle events across sessions, tool calls and sub-agents where hooks attach to extend agent behavior. ([source](https://github.com/lintsinghua/claude-code-book/tree/main/%E7%AC%AC%E4%BA%8C%E9%83%A8%E5%88%86-%E6%A0%B8%E5%BF%83%E7%B3%BB%E7%BB%9F%E7%AF%87))
- [Agent Skill Integrations](https://awesome-repositories.com/f/artificial-intelligence-ml/agent-skill-integrations.md) — Covers adding agent abilities through lifecycle hooks, skills, plugins, layered configuration, and external tool servers over a standard protocol.
- [Agent Tool Systems](https://awesome-repositories.com/f/artificial-intelligence-ml/agent-tool-systems.md) — Teaches a common tool protocol with a fail-closed factory, tool categories, and concurrent execution of safe tools. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/en/README.md))
- [Agent Capability Extensions](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-systems-frameworks/agent-capabilities-skills-tooling/agent-capability-extensions.md) — Explains how hooks, skills, plugins and an external tool protocol let developers extend an agent without changing its core. ([source](https://lintsinghua.github.io/))
- [Agent Skill Frameworks](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-systems-frameworks/agent-capabilities-skills-tooling/agent-skill-frameworks.md) — Covers defining skills through frontmatter files, tiered argument substitution, layered loading and plugin caching to add reusable agent capabilities. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/README.md))
- [Agent Tooling](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-systems-frameworks/agent-capabilities-skills-tooling/agent-tooling.md) — Explains how agents are given tools to read, write and act on their environment, and how tools are defined, selected and invoked. ([source](https://github.com/lintsinghua/claude-code-book/tree/main/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86-%E5%9F%BA%E7%A1%80%E7%AF%87))
- [Agent Tooling Protocols](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-systems-frameworks/agent-capabilities-skills-tooling/agent-tooling-protocols.md) — Covers exposing capabilities as tools through a common protocol, including safe factory defaults and concurrent execution partitioning. ([source](https://github.com/lintsinghua/claude-code-book/tree/main/en))
- [Session Context Managers](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-systems-frameworks/agent-reasoning-engines/agent-context-management/cross-agent-context-managers/session-context-managers.md) — Explains progressive context compression, token budgeting and cross-session memory that keep long agent conversations coherent within model limits.
- [Multi-Agent Orchestration Patterns](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-systems-frameworks/integration-deployment/agent-frameworks/agent-orchestrators/multi-agent-orchestration-patterns.md) — Covers the coordinator-and-worker pattern where one agent delegates tasks to parallel workers and merges their results into one outcome. ([source](https://github.com/lintsinghua/claude-code-book/tree/main/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86-%E9%AB%98%E7%BA%A7%E6%A8%A1%E5%BC%8F%E7%AF%87))
- [Parent Agent Sub-Agent Delegation](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-systems-frameworks/integration-deployment/agent-frameworks/management-and-discovery/agent-registries/programmatic-agent-spawning/parent-agent-sub-agent-delegation.md) — Covers spawning child agents that inherit the parent's exact prompt bytes so they share a cached prefix and cut input token cost. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86-%E9%AB%98%E7%BA%A7%E6%A8%A1%E5%BC%8F%E7%AF%87/09-%E5%AD%90%E6%99%BA%E8%83%BD%E4%BD%93%E4%B8%8EFork%E6%A8%A1%E5%BC%8F.md))
- [Parallel Tool Execution](https://awesome-repositories.com/f/artificial-intelligence-ml/agentic-systems-frameworks/integration-deployment/agent-frameworks/tool-use-and-execution/parallel-tool-execution.md) — Runs read-only tools concurrently while side-effecting tools run serialized, with unknown tools defaulting to the unsafe, fail-closed classification. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E5%9B%9B%E9%83%A8%E5%88%86-%E5%B7%A5%E7%A8%8B%E5%AE%9E%E8%B7%B5%E7%AF%87/13-%E6%B5%81%E5%BC%8F%E6%9E%B6%E6%9E%84%E4%B8%8E%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96.md))
- [Context Compaction Comparisons](https://awesome-repositories.com/f/artificial-intelligence-ml/context-compaction-comparisons.md) — Orders compression approaches from micro compaction through auto compaction and history snipping to full context collapse, showing escalating intensity and trade-offs. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E9%99%84%E5%BD%95/D-%E6%9C%AF%E8%AF%AD%E8%A1%A8.md))
- [Context Memory Management](https://awesome-repositories.com/f/artificial-intelligence-ml/context-memory-management.md) — Explains how persistent cross-session memory and progressive context compression with token budgeting keep an agent effective across long conversations. ([source](https://lintsinghua.github.io/))
- [MCP Protocol Integrations](https://awesome-repositories.com/f/artificial-intelligence-ml/external-tool-integrations/mcp-protocol-integrations.md) — Explains connecting external services over the Model Context Protocol, including connection types, a five-state lifecycle, structured tool naming, and a two-way bridge. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/README.md))
- [Fail-Closed Tool Factories](https://awesome-repositories.com/f/artificial-intelligence-ml/fail-closed-tool-factories.md) — Creates tools through a factory with fail-closed defaults for concurrency and read-only flags, so simple tools need few lines while complex ones override everything. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86-%E5%9F%BA%E7%A1%80%E7%AF%87/03-%E5%B7%A5%E5%85%B7%E7%B3%BB%E7%BB%9F-Agent%E7%9A%84%E5%8F%8C%E6%89%8B.md))
- [Context Summarizations](https://awesome-repositories.com/f/artificial-intelligence-ml/long-context-training-optimizations/context-summarizations.md) — Applies tiered strategies such as trimming old messages and summarizing history to keep long conversations within the token limit while preserving key information. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E5%9B%9B%E9%83%A8%E5%88%86-%E5%B7%A5%E7%A8%8B%E5%AE%9E%E8%B7%B5%E7%AF%87/15-%E6%9E%84%E5%BB%BA%E4%BD%A0%E8%87%AA%E5%B7%B1%E7%9A%84Agent-Harness.md))
- [Multi-Agent Orchestrators](https://awesome-repositories.com/f/artificial-intelligence-ml/multi-agent-orchestrators.md) — Describes coordinator-worker orchestration and forked sub-agents that run in parallel, share a cached prompt prefix and merge results.
- [Agent Response Streams](https://awesome-repositories.com/f/artificial-intelligence-ml/multimodal-agent-capabilities/real-time-streaming/agent-response-streams.md) — Covers streaming model output and tool progress incrementally so users see results sooner and long sessions stay responsive. ([source](https://github.com/lintsinghua/claude-code-book/tree/main/%E7%AC%AC%E5%9B%9B%E9%83%A8%E5%88%86-%E5%B7%A5%E7%A8%8B%E5%AE%9E%E8%B7%B5%E7%AF%87))
- [Prompt Cache Optimizations](https://awesome-repositories.com/f/artificial-intelligence-ml/on-demand-context-retrieval/layered-context-retrievers/prompt-cache-optimizations.md) — Explains keeping system prompts byte-stable and append-only so API prompt caches keep hitting and token costs fall. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86-%E5%9F%BA%E7%A1%80%E7%AF%87/01-%E6%99%BA%E8%83%BD%E4%BD%93%E7%BC%96%E7%A8%8B%E7%9A%84%E6%96%B0%E8%8C%83%E5%BC%8F.md))
- [Forked Agent Prefix Sharing](https://awesome-repositories.com/f/artificial-intelligence-ml/prompt-caching/prefix-caching/forked-agent-prefix-sharing.md) — Builds forked and background agent requests from the parent's identical prefix so cached prompts are reused and input token costs drop. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E4%BA%8C%E9%83%A8%E5%88%86-%E6%A0%B8%E5%BF%83%E7%B3%BB%E7%BB%9F%E7%AF%87/06-%E8%AE%B0%E5%BF%86%E7%B3%BB%E7%BB%9F-Agent%E7%9A%84%E9%95%BF%E6%9C%9F%E8%AE%B0%E5%BF%86.md))
- [Subagent Orchestrations](https://awesome-repositories.com/f/artificial-intelligence-ml/subagent-orchestrations.md) — Covers how subagents inherit context through forking, how a coordinator delegates to workers, and how skills, plugins and bridges extend an agent. ([source](https://github.com/lintsinghua/claude-code-book#readme))
- [Coordinator-Worker Orchestration](https://awesome-repositories.com/f/artificial-intelligence-ml/worker-agent-definitions/coordinator-worker-orchestration.md) — Teaches a coordinator-and-worker architecture where a central agent delegates tasks to parallel workers, gathers results, and combines them into one outcome. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86-%E9%AB%98%E7%BA%A7%E6%A8%A1%E5%BC%8F%E7%AF%87/10-%E5%8D%8F%E8%B0%83%E5%99%A8%E6%A8%A1%E5%BC%8F-%E5%A4%9A%E6%99%BA%E8%83%BD%E4%BD%93%E7%BC%96%E6%8E%92.md))

### Education & Learning Resources

- [Agent Source Code Reports](https://awesome-repositories.com/f/education-learning-resources/agent-source-code-reports.md) — Dissects a real coding agent's source chapter by chapter, with source maps, tool inventories, feature flag references and glossaries.
- [AI Agent Architecture Study Guides](https://awesome-repositories.com/f/education-learning-resources/ai-agent-architecture-study-guides.md) — Dissects a large real-world coding agent chapter by chapter, covering its loop, permissions, compression, and sub-agent scheduling as a study guide. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/00-%E5%89%8D%E8%A8%80.md))

### Security & Cryptography

- [Agent Tool Permissions](https://awesome-repositories.com/f/security-cryptography/security-and-access-control/agent-tool-permissions.md) — Describes a staged permission pipeline across permission modes that gates every agent tool call, with deny rules always winning. ([source](https://github.com/lintsinghua/claude-code-book#readme))
- [Tool Call Permission Pipelines](https://awesome-repositories.com/f/security-cryptography/tool-call-permission-pipelines.md) — Routes every tool call through schema validation, rule matching, hooks, classifiers and user confirmation, where deny rules always override allows and early rejection halts execution.
- [Agent Security Auditing](https://awesome-repositories.com/f/security-cryptography/agent-security-auditing.md) — Covers defenses against prompt injection, tool misuse, runaway spending and malicious hooks using safety flags, trust checks, sanitization and budget caps. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E5%9B%9B%E9%83%A8%E5%88%86-%E5%B7%A5%E7%A8%8B%E5%AE%9E%E8%B7%B5%E7%AF%87/15-%E6%9E%84%E5%BB%BA%E4%BD%A0%E8%87%AA%E5%B7%B1%E7%9A%84Agent-Harness.md))
- [AI Agent Permissions](https://awesome-repositories.com/f/security-cryptography/permission-based-access-control/ai-agent-permissions.md) — Explains how layered permission checks and configuration guard an autonomous agent's actions, including defenses against supply chain attacks. ([source](https://lintsinghua.github.io/))
- [Tool Permission Controllers](https://awesome-repositories.com/f/security-cryptography/permission-management-tools/tool-permission-controllers.md) — Covers layered tool permission handling: filtering tool visibility, validating input, deciding allow, deny or ask by mode and risk, and applying runtime limits. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E4%B8%80%E9%83%A8%E5%88%86-%E5%9F%BA%E7%A1%80%E7%AF%87/01-%E6%99%BA%E8%83%BD%E4%BD%93%E7%BC%96%E7%A8%8B%E7%9A%84%E6%96%B0%E8%8C%83%E5%BC%8F.md))

### Development Tools & Productivity

- [Tool Server Merging](https://awesome-repositories.com/f/development-tools-productivity/ai-coding-assistants/model-context-protocol-servers/tool-server-merging.md) — Connects external tool servers, merges their namespaced tools into the agent's registry with built-ins taking precedence, and reconnects on disconnect. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E9%99%84%E5%BD%95/A-%E6%BA%90%E7%A0%81%E5%AF%BC%E8%88%AA%E5%9C%B0%E5%9B%BE.md))
- [Autonomous Coding Agents](https://awesome-repositories.com/f/development-tools-productivity/autonomous-coding-agents.md) — Breaks down an autonomous coding agent's architecture, including streaming loops, tool protocols, layered configuration, memory and sub-agent delegation.
- [Agent Event Hooks](https://awesome-repositories.com/f/development-tools-productivity/event-automation-hooks/agent-event-hooks.md) — Describes lifecycle events across sessions, tool calls, subagents, compaction, and permissions where hooks attach to run custom commands. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E4%BA%8C%E9%83%A8%E5%88%86-%E6%A0%B8%E5%BF%83%E7%B3%BB%E7%BB%9F%E7%AF%87/08-%E9%92%A9%E5%AD%90%E7%B3%BB%E7%BB%9F-Agent%E7%9A%84%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F%E6%89%A9%E5%B1%95%E7%82%B9.md))
- [MCP Client and Server Implementations](https://awesome-repositories.com/f/development-tools-productivity/vs-code-extensions/mcp-server-configurations/local-mcp-server-launches/mcp-client-and-server-implementations.md) — Layers agent extension through built-in tools, skills, lifecycle hooks, plugins and external protocol servers whose tools are namespaced by server and discovered at runtime.

### Software Engineering & Architecture

- [Environment-Agnostic Agent Cores](https://awesome-repositories.com/f/software-engineering-architecture/environment-agnostic-agent-cores.md) — Injects I/O dependencies through adapters so the same agent loop runs unchanged in terminal, IDE, SDK, and server settings, and tests can substitute fakes. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E5%9B%9B%E9%83%A8%E5%88%86-%E5%B7%A5%E7%A8%8B%E5%AE%9E%E8%B7%B5%E7%AF%87/15-%E6%9E%84%E5%BB%BA%E4%BD%A0%E8%87%AA%E5%B7%B1%E7%9A%84Agent-Harness.md))
- [Agent Skill Extenders](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/extensibility/plugin-architectures/developer-authoring-interfaces/custom-module-implementations/module-functionality-extenders/plugin-extenders/agent-skill-extenders.md) — Describes reusable skills and plugins that extend an agent's abilities through a modular system loading new capabilities on demand. ([source](https://github.com/lintsinghua/claude-code-book/tree/main/%E7%AC%AC%E4%B8%89%E9%83%A8%E5%88%86-%E9%AB%98%E7%BA%A7%E6%A8%A1%E5%BC%8F%E7%AF%87))
- [Priority-Based Configuration Merging](https://awesome-repositories.com/f/software-engineering-architecture/runtime-configuration-overrides/layer-based-configuration-overrides/configuration-sets/priority-based-configuration-merging.md) — Merges settings from enterprise policy, user, project, local and command-line layers with type-aware rules, excluding untrusted project settings from sensitive checks.
- [Agentic Plan-And-Execute Workflows](https://awesome-repositories.com/f/software-engineering-architecture/strategic-planning-workflows/implementation-planning/agentic-plan-and-execute-workflows.md) — Separates read-only planning from execution so users review and approve a plan before any file changes are made. ([source](https://github.com/lintsinghua/claude-code-book/tree/main/%E7%AC%AC%E5%9B%9B%E9%83%A8%E5%88%86-%E5%B7%A5%E7%A8%8B%E5%AE%9E%E8%B7%B5%E7%AF%87))
- [Read-Only Planning Sessions](https://awesome-repositories.com/f/software-engineering-architecture/strategic-planning-workflows/implementation-planning/read-only-planning-sessions.md) — Describes switching a session into a read-only planning mode that saves the prior mode and guides the agent to explore and design without editing. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E5%9B%9B%E9%83%A8%E5%88%86-%E5%B7%A5%E7%A8%8B%E5%AE%9E%E8%B7%B5%E7%AF%87/14-Plan%E6%A8%A1%E5%BC%8F%E4%B8%8E%E7%BB%93%E6%9E%84%E5%8C%96%E5%B7%A5%E4%BD%9C%E6%B5%81.md))
- [Tool Schema Validation](https://awesome-repositories.com/f/software-engineering-architecture/tool-schema-validation.md) — Defines each tool through a typed input schema so validation, permissions, and model-facing descriptions all derive from one declaration with fail-closed defaults. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E5%9B%9B%E9%83%A8%E5%88%86-%E5%B7%A5%E7%A8%8B%E5%AE%9E%E8%B7%B5%E7%AF%87/15-%E6%9E%84%E5%BB%BA%E4%BD%A0%E8%87%AA%E5%B7%B1%E7%9A%84Agent-Harness.md))

### Web Development

- [Agent Lifecycle Hooks](https://awesome-repositories.com/f/web-development/third-party-api-integrations/model-tool-calls/standardized-tool-execution/tool-call-wrappers/agent-tool-interception/agent-lifecycle-hooks.md) — Runs external shell commands at lifecycle points such as before or after a tool call, letting hooks approve, block or modify actions. ([source](https://github.com/lintsinghua/claude-code-book/blob/main/%E7%AC%AC%E5%9B%9B%E9%83%A8%E5%88%86-%E5%B7%A5%E7%A8%8B%E5%AE%9E%E8%B7%B5%E7%AF%87/15-%E6%9E%84%E5%BB%BA%E4%BD%A0%E8%87%AA%E5%B7%B1%E7%9A%84Agent-Harness.md))

### Part of an Awesome List

- [Tutorials and Educational Resources](https://awesome-repositories.com/f/awesome-lists/learning/tutorials-and-educational-resources.md) — Architectural teardown of coding agent harnesses.