{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-shareai-lab--learn-claude-code","slug":"shareai-lab--learn-claude-code","name":"learn-claude-code","type":"agent","url":"https://learn.shareai.run","page_url":"https://unfragile.ai/shareai-lab--learn-claude-code","categories":["ai-agents"],"tags":["agent","agent-development","ai-agent","claude","claude-code","educational","llm","python","teaching","tutorial"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-shareai-lab--learn-claude-code__cap_0","uri":"capability://planning.reasoning.agent.loop.orchestration.with.llm.perception.action.cycles","name":"agent loop orchestration with llm perception-action cycles","description":"Implements a minimal but complete agent loop pattern where an LLM (Claude) perceives environment state, reasons about next actions, and executes tool calls in a synchronous request-response cycle. The harness captures tool outputs as observations, feeds them back into the next loop iteration, and maintains conversation history across cycles. This is the foundational pattern taught in s01 and reused throughout all 12 sessions.","intents":["I want to understand how an AI agent fundamentally works without production complexity","I need to build a simple agent that can perceive state and take actions iteratively","I want to teach others the core loop pattern before adding multi-agent or persistence layers"],"best_for":["educators teaching AI agent architecture","developers learning harness engineering principles","teams prototyping agent behavior before scaling"],"limitations":["No session persistence — agent state is lost between process restarts","Single-threaded synchronous loop — cannot handle concurrent tool execution","No built-in error recovery — tool failures propagate directly to LLM without retry logic","Context window grows unbounded — no automatic conversation pruning or summarization"],"requires":["Python 3.8+","Anthropic API key for Claude access","TypeScript/Node.js 16+ for harness framework"],"input_types":["natural language task description","tool output as text/JSON"],"output_types":["tool invocations (function calls)","reasoning text","final response"],"categories":["planning-reasoning","agent-architecture"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_1","uri":"capability://tool.use.integration.tool.dispatch.with.schema.based.function.calling","name":"tool dispatch with schema-based function calling","description":"Routes LLM-generated tool calls to concrete implementations (bash, read_file, write_file, edit_file, load_skill, task_* operations) via a schema registry that defines input/output contracts. The harness validates tool schemas against LLM requests, executes the tool in an isolated context, captures output, and returns it to the agent. This is taught in s02 and extended throughout the curriculum.","intents":["I want the agent to execute bash commands safely without arbitrary code execution","I need to define what tools the agent can call and validate their inputs before execution","I want to add new tools without modifying the core agent loop"],"best_for":["developers building agent toolkits with safety constraints","teams implementing tool governance and permission models","educators demonstrating tool abstraction layers"],"limitations":["No parallel tool execution — tools run sequentially, blocking the agent loop","Schema validation is basic — no complex type constraints or conditional validation","Tool output is always stringified — binary or streaming outputs require custom serialization","No built-in tool versioning — schema changes require manual migration"],"requires":["Python 3.8+","Tool implementations must be synchronous functions","Schema definitions in JSON or Python dataclass format"],"input_types":["tool name (string)","tool arguments (JSON object)"],"output_types":["tool result (string or JSON)","error message (string)"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_10","uri":"capability://planning.reasoning.autonomous.task.claiming.and.work.distribution","name":"autonomous task claiming and work distribution","description":"Implements a task claiming mechanism (s11) where agents autonomously claim tasks from a shared task board based on their capabilities and current workload. Agents can evaluate task requirements, decide whether to claim a task, and update task status. This enables self-organizing agent teams without a central scheduler.","intents":["I want agents to autonomously decide which tasks to work on based on their skills","I need to distribute work across a team of agents without a central coordinator","I want to teach agents about capability-based task selection and load balancing"],"best_for":["developers building self-organizing agent teams","teams implementing decentralized task distribution","educators teaching autonomous agent coordination"],"limitations":["No load balancing — agents may all claim the same high-priority task","No capability matching — agents must manually evaluate task requirements","No conflict resolution — concurrent claims of the same task require manual handling","No fairness guarantees — some agents may starve while others are overloaded"],"requires":["Python 3.8+","Shared task board (TodoManager or TaskManager)","Agent capability definitions"],"input_types":["task (with requirements and metadata)","agent capabilities (list of skills)"],"output_types":["claim decision (boolean)","claimed task ID (string)"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_11","uri":"capability://automation.workflow.worktree.isolation.and.filesystem.sandboxing","name":"worktree isolation and filesystem sandboxing","description":"Implements WorktreeManager (s12) that creates isolated filesystem subtrees for each agent or task, preventing cross-contamination and enabling parallel execution. Each worktree is a separate directory with its own file state, and agents can only access files within their worktree. This is the final session and combines all previous concepts into a complete isolated execution environment.","intents":["I want to prevent agents from interfering with each other's files","I need to run multiple agents in parallel on the same codebase without conflicts","I want to teach filesystem isolation and sandboxing patterns"],"best_for":["developers building multi-agent systems that modify files","teams implementing agent sandboxing and isolation","educators teaching filesystem isolation patterns"],"limitations":["Worktree creation adds overhead — each worktree requires filesystem copy or symlink setup","No automatic cleanup — worktrees must be manually deleted or garbage collected","Cross-worktree communication is manual — agents must explicitly share results","Filesystem operations are slower — isolation adds I/O overhead compared to shared filesystem"],"requires":["Python 3.8+","Filesystem access for creating worktrees","WorktreeManager component"],"input_types":["worktree name (string)","base directory (path)","initial files (optional)"],"output_types":["worktree path (string)","worktree metadata (JSON)"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_12","uri":"capability://planning.reasoning.pedagogical.progression.through.12.learning.sessions","name":"pedagogical progression through 12 learning sessions","description":"Structures the entire framework as a 12-session curriculum (s01–s12) where each session introduces exactly one harness mechanism without modifying the core agent loop. Sessions build incrementally: s01 teaches the loop, s02 adds tools, s03 adds planning, s04 adds subagents, s05 adds skills, s06 adds compression, s07 adds tasks, s08 adds background execution, s09 adds teams, s10 adds protocols, s11 adds autonomous claiming, s12 adds worktree isolation. This design makes the framework explicitly educational and modular.","intents":["I want to learn harness engineering from first principles without production complexity","I need a structured curriculum that builds understanding incrementally","I want to teach others agent architecture by showing one concept at a time"],"best_for":["students learning AI agent architecture","educators teaching harness engineering","developers building mental models before using production frameworks"],"limitations":["Educational design means some production features are omitted (event hooks, rule-based governance, session lifecycle)","Each session is self-contained — code from earlier sessions is not directly reused","No production-ready deployment — the framework is intentionally simplified for teaching"],"requires":["Python 3.8+","Anthropic API key","Time to work through all 12 sessions sequentially"],"input_types":["session code (Python scripts)","session documentation (markdown)"],"output_types":["working agent implementation","understanding of harness engineering principles"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_2","uri":"capability://safety.moderation.safe.path.validation.and.dangerous.command.blocking","name":"safe path validation and dangerous command blocking","description":"Implements a permission layer that validates file paths against a safe_path whitelist before executing read/write/edit operations, and blocks dangerous bash commands (rm -rf, sudo, etc.) via a blocklist. The harness intercepts tool calls at dispatch time, checks paths and commands against rules, and rejects unsafe operations before they reach the OS. This is a core security mechanism taught in the overview and applied throughout.","intents":["I want to prevent the agent from deleting critical files or running privileged commands","I need to restrict the agent to a specific directory tree or set of files","I want to audit which files and commands the agent attempts to access"],"best_for":["teams deploying agents in shared or production environments","developers building agent sandboxes with strict isolation","security-conscious organizations requiring audit trails"],"limitations":["Blocklist-based approach — new dangerous commands must be manually added","Path validation is filesystem-level only — no semantic understanding of file importance","No granular permissions — either a path is safe or it isn't, no role-based access control","Blocking is synchronous — no async approval workflows for borderline operations"],"requires":["Python 3.8+","safe_path configuration (list of allowed directories)","dangerous_commands configuration (list of blocked bash patterns)"],"input_types":["file path (string)","bash command (string)"],"output_types":["boolean (allowed/blocked)","error message (string)"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_3","uri":"capability://planning.reasoning.planning.and.task.decomposition.via.todomanager","name":"planning and task decomposition via todomanager","description":"Provides a persistent task board (TodoManager) where agents can write, read, and update tasks in a structured format. Tasks are stored as markdown with metadata (status, assignee, priority), and the agent can decompose complex goals into subtasks, track progress, and coordinate with other agents. This is introduced in s03 and extended in s07 (TaskManager) and s09 (multi-agent teams).","intents":["I want the agent to break down a large goal into smaller, manageable tasks","I need to track what the agent has completed and what remains","I want multiple agents to see a shared task board and coordinate work"],"best_for":["developers building multi-step agent workflows","teams implementing agent task coordination","educators teaching planning and decomposition patterns"],"limitations":["No conflict resolution — concurrent writes from multiple agents can corrupt task state","No task dependencies — cannot express 'task B depends on task A completion'","Markdown-based storage — no structured query or filtering beyond text search","No automatic task lifecycle — tasks don't auto-expire or escalate if stalled"],"requires":["Python 3.8+","Filesystem access for task storage","Markdown parsing library"],"input_types":["task description (string)","task status (enum: todo, in_progress, done)","task metadata (assignee, priority, due_date)"],"output_types":["task list (markdown)","task state (JSON)"],"categories":["planning-reasoning","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_4","uri":"capability://planning.reasoning.subagent.spawning.with.context.isolation","name":"subagent spawning with context isolation","description":"Allows a parent agent to spawn child agents (subagents) with isolated context, separate tool access, and independent task boards. Each subagent runs its own agent loop with a subset of the parent's tools and knowledge, and communicates back via message passing. This is taught in s04 and forms the foundation for multi-agent teams in s09.","intents":["I want to delegate a subtask to a specialized agent without exposing all parent tools","I need to run multiple agents in parallel with isolated state","I want to teach hierarchical agent decomposition and delegation patterns"],"best_for":["developers building hierarchical agent systems","teams implementing agent specialization and role-based access","educators teaching multi-agent coordination"],"limitations":["Subagents are spawned synchronously — parent blocks until subagent completes","Context isolation is manual — developer must explicitly define which tools/knowledge each subagent sees","No automatic context merging — parent must manually integrate subagent results","Subagent failures propagate to parent — no built-in error recovery or retry"],"requires":["Python 3.8+","Parent agent must define subagent configuration (tools, knowledge, task)","Message passing mechanism (MessageBus in s10+)"],"input_types":["subagent configuration (JSON)","task description (string)","tool whitelist (list of tool names)"],"output_types":["subagent result (string or JSON)","subagent logs (text)"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_5","uri":"capability://memory.knowledge.dynamic.skill.loading.and.knowledge.injection","name":"dynamic skill loading and knowledge injection","description":"Implements a SkillLoader that reads markdown files from a skills/ directory and injects them into the agent's context as knowledge. Skills are markdown documents describing tools, APIs, or domain knowledge that the agent can reference during reasoning. The two-layer injection strategy (s05) allows skills to be loaded at runtime without modifying the agent loop or tool registry.","intents":["I want to add domain knowledge to the agent without retraining it","I need to update agent capabilities (new APIs, libraries, patterns) without code changes","I want to teach agents about new tools by providing documentation they can read"],"best_for":["developers building extensible agent systems","teams managing agent knowledge updates","educators demonstrating knowledge injection patterns"],"limitations":["Skills are loaded into context — large skill sets increase token usage and latency","No skill versioning — multiple versions of the same skill can cause conflicts","No skill dependency resolution — skills cannot declare dependencies on other skills","Skills are read-only from agent perspective — agents cannot modify or create new skills at runtime"],"requires":["Python 3.8+","Markdown files in skills/ directory","SkillLoader component"],"input_types":["skill name (string)","skill markdown file (text)"],"output_types":["skill content injected into context (text)","skill metadata (JSON)"],"categories":["memory-knowledge","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_6","uri":"capability://data.processing.analysis.context.compression.and.token.optimization","name":"context compression and token optimization","description":"Implements a context compression pipeline (s06) that summarizes or prunes conversation history, task boards, and skill content to reduce token usage while preserving semantic meaning. The harness can compress context before sending to the LLM, trading off detail for cost and latency. Compression strategies include summarization, chunking, and selective retention of recent/important messages.","intents":["I want to reduce API costs by compressing agent context before sending to Claude","I need to keep agent conversations under the context window limit","I want to optimize latency by reducing tokens sent to the LLM"],"best_for":["developers deploying agents at scale with cost constraints","teams managing long-running agent sessions","builders optimizing for latency-sensitive applications"],"limitations":["Compression is lossy — summarization may lose nuanced details important to reasoning","No adaptive compression — compression strategy is static, not tuned to task type","Compression adds latency — summarization itself requires LLM calls or complex algorithms","No compression metrics — difficult to measure impact of compression on agent performance"],"requires":["Python 3.8+","Compression algorithm (summarization, chunking, or filtering)","Token counting library (e.g., tiktoken)"],"input_types":["conversation history (list of messages)","task board (markdown)","skill content (text)"],"output_types":["compressed context (text)","compression metadata (token count, compression ratio)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_7","uri":"capability://automation.workflow.background.task.execution.and.async.job.management","name":"background task execution and async job management","description":"Provides a BackgroundManager (s08) that allows agents to spawn long-running tasks that execute asynchronously while the agent loop continues. Background tasks are tracked in a job queue, can be polled for status, and can emit events when complete. This enables agents to parallelize work without blocking the main loop.","intents":["I want the agent to start a long-running task and continue reasoning while it executes","I need to track the status of multiple background jobs spawned by the agent","I want to teach agents about asynchronous work patterns and job coordination"],"best_for":["developers building agents that coordinate long-running operations","teams implementing agent job queues and schedulers","educators teaching async patterns in agent systems"],"limitations":["Background tasks are in-process only — no distributed job execution","No persistence — background jobs are lost if the process crashes","No retry logic — failed background tasks don't automatically retry","Job polling is manual — agent must explicitly check job status, no automatic notifications"],"requires":["Python 3.8+","Async/await support or threading library","BackgroundManager component"],"input_types":["task function (callable)","task arguments (dict)","task metadata (priority, timeout)"],"output_types":["job ID (string)","job status (enum: queued, running, completed, failed)","job result (any type)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_8","uri":"capability://tool.use.integration.multi.agent.team.coordination.with.messagebus","name":"multi-agent team coordination with messagebus","description":"Implements a MessageBus (s10) that allows multiple agents to communicate asynchronously via message passing. Agents can publish messages to topics, subscribe to topics, and react to messages from teammates. This enables team protocols (FSMs, workflows) where agents coordinate work without shared mutable state. Teams are taught in s09, with protocols in s10.","intents":["I want multiple agents to coordinate work without shared state or locks","I need to implement team workflows where agents react to each other's actions","I want to teach message-passing patterns and event-driven agent coordination"],"best_for":["developers building multi-agent systems with loose coupling","teams implementing agent team protocols and FSMs","educators teaching distributed agent coordination"],"limitations":["MessageBus is in-process only — no distributed messaging across processes or machines","No message persistence — messages are lost if not consumed immediately","No message ordering guarantees — concurrent messages may be processed out of order","No backpressure — fast publishers can overwhelm slow subscribers"],"requires":["Python 3.8+","MessageBus component","Message schema definitions"],"input_types":["message topic (string)","message payload (JSON or dict)"],"output_types":["message delivery confirmation (boolean)","subscriber responses (list of results)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shareai-lab--learn-claude-code__cap_9","uri":"capability://planning.reasoning.team.protocols.and.finite.state.machine.workflows","name":"team protocols and finite state machine workflows","description":"Allows teams of agents to follow structured protocols defined as finite state machines (FSMs) or workflow specifications. Protocols define valid state transitions, which agents can trigger via messages, and enforce rules about who can do what in each state. This is taught in s10 and enables complex multi-agent behaviors like approval workflows, handoffs, and consensus patterns.","intents":["I want to enforce rules about how agents can interact (e.g., only reviewer can approve)","I need to implement complex workflows like approval chains or task handoffs","I want to teach formal protocol design for multi-agent systems"],"best_for":["developers building agent workflows with strict rules","teams implementing governance and approval processes","educators teaching formal protocol design"],"limitations":["FSM-based protocols are rigid — complex behaviors require large state spaces","No dynamic protocol modification — protocols are static, cannot adapt to new agents or rules","No protocol composition — cannot easily combine multiple protocols","Deadlock detection is manual — no automatic detection of protocol violations or stuck states"],"requires":["Python 3.8+","FSM library or custom state machine implementation","Protocol definition format (JSON or Python dataclass)"],"input_types":["protocol definition (FSM specification)","current state (string)","message/action (string)"],"output_types":["next state (string)","allowed actions (list of strings)","validation result (boolean)"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":52,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","Anthropic API key for Claude access","TypeScript/Node.js 16+ for harness framework","Tool implementations must be synchronous functions","Schema definitions in JSON or Python dataclass format","Shared task board (TodoManager or TaskManager)","Agent capability definitions","Filesystem access for creating worktrees","WorktreeManager component","Anthropic API key"],"failure_modes":["No session persistence — agent state is lost between process restarts","Single-threaded synchronous loop — cannot handle concurrent tool execution","No built-in error recovery — tool failures propagate directly to LLM without retry logic","Context window grows unbounded — no automatic conversation pruning or summarization","No parallel tool execution — tools run sequentially, blocking the agent loop","Schema validation is basic — no complex type constraints or conditional validation","Tool output is always stringified — binary or streaming outputs require custom serialization","No built-in tool versioning — schema changes require manual migration","No load balancing — agents may all claim the same high-priority task","No capability matching — agents must manually evaluate task requirements","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.8583028487519959,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.063Z","last_scraped_at":"2026-05-03T13:57:04.027Z","last_commit":"2026-04-14T16:58:21Z"},"community":{"stars":57903,"forks":9503,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=shareai-lab--learn-claude-code","compare_url":"https://unfragile.ai/compare?artifact=shareai-lab--learn-claude-code"}},"signature":"XtHWg2+xW8Fm2dvI9hcExpnrquDTdfxLq7ic55bG1/RGYoXElVU/pIIPWZq/scKTFWuJxyUOhSJNcFF2GbJBAQ==","signedAt":"2026-06-22T01:04:58.226Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/shareai-lab--learn-claude-code","artifact":"https://unfragile.ai/shareai-lab--learn-claude-code","verify":"https://unfragile.ai/api/v1/verify?slug=shareai-lab--learn-claude-code","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}