{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-shanraisshan--claude-code-best-practice","slug":"shanraisshan--claude-code-best-practice","name":"claude-code-best-practice","type":"agent","url":"https://linkedin.com/in/shanraisshan","page_url":"https://unfragile.ai/shanraisshan--claude-code-best-practice","categories":["productivity"],"tags":["agentic-ai","agentic-coding","agentic-engineering","agentic-workflow","ai","ai-agents","anthropic","best-practices","boris","claude","claude-ai","claude-code","claude-code-agents","claude-code-best-practices","claude-code-commands","claude-code-skills","context-engineering","pakistan","pakistani-developer","vibe-coding"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"inactive","verified":false},"capabilities":[{"id":"github-shanraisshan--claude-code-best-practice__cap_0","uri":"capability://planning.reasoning.command.to.agent.to.skill.orchestration.pipeline","name":"command-to-agent-to-skill orchestration pipeline","description":"Implements a three-tier hierarchical execution model where user commands trigger specialized agents, which decompose work into reusable skills with isolated execution contexts. Commands are defined as markdown files in .claude/commands/, routed to agents (general-purpose, Explore, Plan, or custom), which invoke skills (simplify, batch, loop, or custom) with persistent memory and lifecycle hooks. This architecture enables deterministic automation through 17+ lifecycle events (PreToolUse, SessionStart, Stop, etc.) that intercept and modify agent behavior at runtime.","intents":["I want to build multi-step workflows where commands trigger specialized agents without context pollution","I need to decompose complex tasks into reusable, composable skills that can be chained together","I want to intercept and modify agent behavior at specific lifecycle points without rewriting agent logic"],"best_for":["teams building production Claude Code agents with complex multi-step workflows","developers migrating from monolithic agent implementations to modular skill-based architectures","engineers requiring deterministic automation with fine-grained lifecycle control"],"limitations":["Skill composition adds ~50-100ms per skill invocation due to context switching between isolated execution environments","Lifecycle hooks execute synchronously, blocking agent progress if hook logic is slow; no async hook support","Memory isolation between agents prevents direct cross-agent state sharing; requires explicit message passing or shared storage","Skill reusability depends on careful interface design; tightly coupled skills cannot be reused across different agent types"],"requires":["Claude Code environment with .claude/ directory structure support","Markdown-based command definitions in .claude/commands/","Agent type support (general-purpose, Explore, Plan, or custom agent definitions)","Skill definitions with clear input/output contracts"],"input_types":["markdown command definitions","agent configuration files","skill definitions with parameters","lifecycle hook event payloads"],"output_types":["agent execution results","skill output artifacts","lifecycle event responses","structured execution logs"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_1","uri":"capability://automation.workflow.hierarchical.settings.and.configuration.precedence.system","name":"hierarchical settings and configuration precedence system","description":"Implements a 5-level configuration precedence hierarchy (managed > CLI > local > project > user) where settings cascade from highest-priority managed configurations down to user defaults, with each level overriding lower levels. Settings are stored in CLAUDE.md files (project-level) and user config directories, supporting environment variables, model selection, permissions, sandbox security, and context budgets. The system uses a settings resolution algorithm that walks the precedence chain at runtime, enabling dynamic reconfiguration without restarting the agent.","intents":["I want to enforce organization-wide Claude Code policies (managed settings) that override user preferences","I need to configure different models, permissions, and context budgets per project without duplicating configuration","I want to override settings via CLI flags for one-off runs without modifying persistent configuration files"],"best_for":["enterprise teams managing multiple Claude Code projects with centralized policy requirements","developers working across projects with different model requirements and permission models","DevOps engineers setting up CI/CD pipelines with environment-specific configurations"],"limitations":["Settings resolution happens at agent startup; dynamic runtime changes to settings require agent restart","No built-in validation schema for settings; invalid configurations fail silently or at runtime","Environment variable expansion is limited to simple string substitution; no complex templating or computed values","Settings precedence is linear; no conditional logic or context-aware overrides (e.g., different settings per branch)"],"requires":["CLAUDE.md file in project root for project-level settings","User config directory (platform-specific: ~/.claude/ on Unix, %APPDATA%/Claude/ on Windows)","Support for environment variable expansion in configuration values","Claude Code CLI with --setting flag support for CLI-level overrides"],"input_types":["CLAUDE.md markdown files","user configuration files (JSON or YAML)","environment variables","CLI flags (--setting key=value)"],"output_types":["resolved configuration object","effective settings at runtime","configuration validation errors"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_10","uri":"capability://automation.workflow.scheduled.tasks.and.long.running.workflow.orchestration","name":"scheduled tasks and long-running workflow orchestration","description":"Provides a scheduling system for long-running agent workflows that execute on defined schedules (cron-like expressions) with support for task queuing, retry logic, and progress tracking. The system manages task lifecycle (scheduled, running, completed, failed), persists task state across restarts, and enables resumption of interrupted tasks. Scheduled tasks can be chained (task A triggers task B) and can access shared state through the memory system.","intents":["I want to run agents on a schedule (e.g., daily data processing, periodic monitoring) without manual intervention","I need to handle long-running tasks that may be interrupted and resume from where they left off","I want to chain multiple tasks together (e.g., task A generates data, task B processes it) with automatic triggering"],"best_for":["teams running periodic agent workflows (data processing, monitoring, reporting)","developers building long-running agents that need to survive restarts and interruptions","organizations automating routine tasks that would otherwise require manual execution"],"limitations":["Scheduling is local to the agent runtime; no distributed scheduling across multiple machines","Task state persistence is not transactional; interrupted tasks may leave partial state that requires manual cleanup","Retry logic is basic; no exponential backoff or sophisticated failure handling strategies","Task chaining is manual; no automatic dependency resolution or DAG-based task orchestration"],"requires":["Scheduling configuration (cron expressions or interval-based)","Task state persistence (file-based or database-backed)","Retry logic configuration (max retries, backoff strategy)","Task queue implementation (in-memory or persistent)"],"input_types":["schedule definitions (cron expressions)","task definitions with parameters","task state snapshots","retry configuration"],"output_types":["scheduled task execution results","task state updates","execution logs with timestamps","retry attempt records"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_11","uri":"capability://automation.workflow.agent.team.coordination.with.shared.context.and.message.passing","name":"agent team coordination with shared context and message passing","description":"Enables multiple agents to work together as a team with explicit message passing, shared context repositories, and coordination protocols. Agents can send messages to other agents, access shared memory stores, and coordinate on complex tasks through a message queue system. The architecture prevents direct state coupling while enabling controlled information flow between agents through well-defined message interfaces.","intents":["I want multiple agents to collaborate on complex tasks (e.g., one agent researches, another writes, a third reviews)","I need to coordinate agent execution (e.g., agent A waits for agent B's output before proceeding)","I want to share knowledge between agents without direct state coupling (e.g., agent A's findings inform agent B's decisions)"],"best_for":["teams building multi-agent systems where agents need to collaborate on complex tasks","developers implementing agent workflows with explicit coordination points","organizations requiring audit trails of inter-agent communication"],"limitations":["Message passing adds latency; agents must wait for responses, blocking execution","No automatic deadlock detection; circular message dependencies can cause agents to wait indefinitely","Message ordering is not guaranteed in asynchronous scenarios; agents may receive messages out of order","Shared context consistency is not enforced; concurrent writes from multiple agents may cause conflicts"],"requires":["Message queue implementation (in-memory or persistent)","Message interface definitions (schema for inter-agent messages)","Shared context repository (file-based or database-backed)","Coordination protocol definitions (message flow, synchronization points)"],"input_types":["agent messages with structured payloads","shared context updates","coordination protocol definitions","agent team configuration"],"output_types":["message delivery confirmations","shared context snapshots","inter-agent communication logs","team execution results"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_12","uri":"capability://automation.workflow.self.evolution.and.documentation.maintenance.with.automated.updates","name":"self-evolution and documentation maintenance with automated updates","description":"Provides a system for agents to automatically update their own documentation, CLAUDE.md files, and configuration based on execution experience and learned patterns. Agents can analyze their own behavior, identify improvements, and propose or apply updates to documentation and configuration without manual intervention. This enables agents to improve over time and maintain accurate documentation as they evolve.","intents":["I want agents to automatically update documentation when they discover new patterns or best practices","I need to keep CLAUDE.md files in sync with actual agent behavior without manual updates","I want agents to learn from their own execution and improve their configuration over time"],"best_for":["teams building agents that evolve over time and need to maintain accurate documentation","developers wanting to reduce manual documentation maintenance overhead","organizations with large agent fleets that need to stay synchronized with actual behavior"],"limitations":["Self-modification can introduce bugs; agents may propose incorrect updates that break functionality","No rollback mechanism; incorrect self-modifications may require manual intervention to revert","Documentation quality depends on agent reasoning; agents may generate inaccurate or incomplete documentation","Concurrent self-modifications from multiple agents can cause conflicts in shared configuration files"],"requires":["Write permissions to CLAUDE.md and configuration files","Mechanism for agents to propose and apply updates","Validation logic to prevent obviously incorrect updates","Version control integration for tracking changes"],"input_types":["agent execution logs and results","pattern analysis from execution history","proposed documentation updates","configuration change requests"],"output_types":["updated CLAUDE.md files","updated configuration files","change proposals for review","self-evolution reports"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_13","uri":"capability://automation.workflow.cli.and.slash.command.interface.with.power.ups.and.extensibility","name":"cli and slash command interface with power-ups and extensibility","description":"Provides a command-line interface (CLI) with built-in slash commands (e.g., /plan, /explore, /simplify, /batch, /loop) and a power-ups system for extending CLI functionality. Slash commands map to agents and skills, with support for command composition (chaining commands), parameter passing, and output formatting. Power-ups are plugins that add new slash commands or modify existing ones, enabling extensibility without modifying core CLI code.","intents":["I want to interact with Claude Code agents through a familiar CLI interface with slash commands","I need to compose multiple commands together (e.g., /plan then /explore then /simplify) in a single workflow","I want to extend the CLI with custom commands (power-ups) for domain-specific tasks"],"best_for":["developers familiar with CLI tools and preferring command-line interaction over GUI","teams building custom workflows that require command composition and scripting","organizations developing power-ups to extend Claude Code for domain-specific use cases"],"limitations":["CLI interface is text-based; no rich UI for complex interactions or visualizations","Command composition is manual; no automatic workflow generation or optimization","Power-up discovery is manual; no central registry or automatic installation mechanism","Parameter passing is string-based; complex data structures require serialization/deserialization"],"requires":["CLI implementation with argument parsing","Slash command registry and routing logic","Power-up plugin system with discovery and loading","Output formatting and display logic"],"input_types":["CLI arguments and flags","slash command definitions","power-up plugin definitions","command composition specifications"],"output_types":["command execution results","formatted CLI output","command composition results","power-up installation confirmations"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_14","uri":"capability://planning.reasoning.vibe.coding.to.agentic.engineering.progression.framework","name":"vibe coding to agentic engineering progression framework","description":"Provides a structured learning path and best practices guide for transitioning from ad-hoc 'vibe coding' (exploratory, unstructured prompting) to production-grade agentic engineering with formal patterns, configuration management, and architectural discipline. The framework documents anti-patterns, common pitfalls, and recommended practices at each stage of maturity, with examples and case studies demonstrating the progression.","intents":["I want to understand how to evolve my Claude Code usage from exploratory prompting to production-grade agent systems","I need best practices and patterns for building reliable, maintainable agent systems at scale","I want to learn from common mistakes and anti-patterns to avoid them in my own projects"],"best_for":["developers new to agentic engineering wanting to learn best practices","teams transitioning from ad-hoc Claude usage to structured agent systems","organizations establishing standards and patterns for Claude Code development"],"limitations":["Framework is prescriptive; may not fit all use cases or organizational contexts","Best practices are documented but not enforced; developers can ignore recommendations","Framework assumes familiarity with Claude Code; not suitable for complete beginners","Patterns are based on community experience; may not reflect all edge cases or novel use cases"],"requires":["Documentation of progression stages and maturity levels","Examples and case studies demonstrating each stage","Anti-patterns and common pitfalls documentation","Best practices guide with concrete recommendations"],"input_types":["developer experience level and current practices","project requirements and constraints","organizational standards and policies"],"output_types":["progression recommendations","best practices guidance","anti-pattern warnings","example implementations"],"categories":["planning-reasoning","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_2","uri":"capability://automation.workflow.context.budget.management.and.token.accounting","name":"context budget management and token accounting","description":"Tracks and enforces context window usage across agent executions using a token accounting system that measures input tokens, output tokens, and cumulative context consumption. The system allocates context budgets per agent, per command, and per session, with real-time monitoring and enforcement that prevents agents from exceeding allocated token limits. Context budgets are configured in settings and can be adjusted per project or per execution, with detailed logging of token usage per skill invocation and agent step.","intents":["I want to prevent runaway agent executions from consuming excessive tokens and incurring unexpected costs","I need to understand token consumption patterns across different agents and skills to optimize context usage","I want to set different context budgets for different projects or execution modes (e.g., strict budgets for production, generous for development)"],"best_for":["teams operating Claude Code agents at scale with cost-sensitive deployments","developers optimizing agent efficiency and context window utilization","organizations with token quotas or billing constraints per project or team"],"limitations":["Token counting is approximate; actual token usage may differ from estimates due to tokenizer differences between Claude versions","Budget enforcement is hard-stop; agents terminate immediately when budget is exceeded, potentially leaving tasks incomplete","No graceful degradation or budget-aware task prioritization; all tasks are treated equally regardless of importance","Context budget accounting does not account for tool use or external API calls; only LLM token consumption is tracked"],"requires":["Token counting library compatible with Claude's tokenizer (e.g., tiktoken or Anthropic's token counter)","Context budget configuration in CLAUDE.md or settings files","Real-time token usage reporting from Claude API responses","Logging infrastructure to capture and analyze token consumption patterns"],"input_types":["agent execution requests with context","token usage data from Claude API","context budget configuration values"],"output_types":["token usage reports per agent/skill","budget enforcement decisions (allow/deny)","cost projections and warnings"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_3","uri":"capability://memory.knowledge.agent.memory.architecture.with.persistent.state.and.retrieval","name":"agent memory architecture with persistent state and retrieval","description":"Provides a multi-tier memory system for agents including short-term context (current conversation), long-term persistent memory (stored between sessions), and episodic memory (task-specific execution logs). Memory is stored in agent-specific directories with structured formats (JSON, markdown), indexed for semantic retrieval, and accessible via memory-aware skills (e.g., recall, summarize). The system supports memory isolation between agents, preventing cross-agent state leakage, while enabling explicit memory sharing through message passing or shared memory stores.","intents":["I want agents to remember previous interactions and learn from past executions without retraining","I need to debug agent behavior by reviewing detailed execution logs and memory state at each step","I want to share knowledge between agents (e.g., one agent's findings inform another agent's decisions) without direct state coupling"],"best_for":["teams building long-running agents that improve over time through experience","developers debugging complex multi-agent systems and needing execution visibility","organizations requiring audit trails and reproducibility of agent decisions"],"limitations":["Memory retrieval is not semantic by default; requires manual indexing or external vector database for similarity search","Memory isolation prevents direct cross-agent access; sharing memory requires explicit message passing, adding latency","No automatic memory pruning or garbage collection; memory stores grow unbounded unless manually cleaned","Memory consistency is not guaranteed in concurrent scenarios; multiple agents writing to shared memory may cause conflicts"],"requires":["Agent-specific storage directory (e.g., .claude/agents/{agent-name}/memory/)","Structured memory format support (JSON for structured data, markdown for logs)","Memory indexing infrastructure (optional, for semantic retrieval)","Explicit memory sharing protocol (message passing or shared store configuration)"],"input_types":["agent execution context","task results and outputs","memory queries (semantic or keyword-based)","explicit memory write operations"],"output_types":["retrieved memory artifacts","memory state snapshots","execution logs and traces","memory consistency reports"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_4","uri":"capability://tool.use.integration.mcp.server.integration.and.external.tool.orchestration","name":"mcp server integration and external tool orchestration","description":"Integrates Model Context Protocol (MCP) servers to connect Claude Code agents with external tools, databases, APIs, and services via a standardized .mcp.json configuration file. The system discovers MCP servers, establishes connections, exposes their capabilities as callable tools within agent skills, and handles request/response marshaling between agents and external services. MCP integration enables agents to access real-time data, execute system commands, query databases, and invoke third-party APIs without hardcoding tool logic.","intents":["I want to connect my Claude Code agents to external APIs, databases, and tools without writing custom integration code","I need to expose system capabilities (file access, command execution, database queries) to agents in a controlled, sandboxed manner","I want to reuse MCP servers across multiple agents and projects without duplicating configuration"],"best_for":["teams integrating Claude Code with existing tool ecosystems (Slack, GitHub, Jira, databases)","developers building agents that require real-time data access or system-level capabilities","organizations standardizing on MCP as the integration layer for AI agents"],"limitations":["MCP server availability is not guaranteed; agent execution fails if a required MCP server is unavailable or misconfigured","Tool discovery and capability exposure is static (defined in .mcp.json); dynamic tool registration requires configuration changes and agent restart","Error handling for MCP failures is basic; timeouts, connection errors, and malformed responses may not be gracefully handled","MCP server performance directly impacts agent latency; slow external services block agent execution"],"requires":[".mcp.json configuration file in project root with MCP server definitions","MCP server implementations (built-in or third-party) for each external service","Network connectivity to MCP servers (local or remote)","Proper authentication credentials for MCP servers (API keys, connection strings, etc.)"],"input_types":[".mcp.json configuration with server definitions","MCP server capability schemas","agent tool invocation requests","external service responses"],"output_types":["exposed tool capabilities","tool execution results","error responses from external services","MCP server status and diagnostics"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_5","uri":"capability://memory.knowledge.context.engineering.and.claude.md.based.knowledge.injection","name":"context engineering and claude.md-based knowledge injection","description":"Provides a system for injecting project-specific context, rules, and knowledge into agent execution through CLAUDE.md files that define project structure, conventions, best practices, and domain-specific instructions. The system parses CLAUDE.md files, extracts context blocks, and injects them into agent prompts at runtime, enabling agents to understand project conventions without explicit training. Context injection is hierarchical (project-level, directory-level, file-level) and respects context budget constraints.","intents":["I want agents to understand my project structure, coding conventions, and domain-specific rules without explicit prompting","I need to define project-wide guidelines that all agents follow consistently (e.g., naming conventions, architecture patterns)","I want to inject file-specific context (e.g., API documentation, schema definitions) into agent prompts for better code generation"],"best_for":["teams with large codebases requiring agents to understand project conventions and architecture","developers building domain-specific agents that need specialized knowledge (e.g., medical, financial, legal domains)","organizations standardizing on CLAUDE.md as the source of truth for agent context and project guidelines"],"limitations":["Context injection increases token consumption; large CLAUDE.md files can quickly exhaust context budgets","No automatic context relevance filtering; all context is injected regardless of task relevance, leading to noise","CLAUDE.md parsing is fragile; malformed markdown or unsupported syntax may cause context injection to fail silently","Context staleness; CLAUDE.md changes require agent restart to take effect, preventing dynamic context updates"],"requires":["CLAUDE.md file in project root with context blocks and project guidelines","Markdown parsing library compatible with CLAUDE.md syntax","Context budget allocation for injected context (separate from agent execution budget)","Mechanism to inject context into agent system prompts at runtime"],"input_types":["CLAUDE.md markdown files","project structure metadata","file-specific context annotations","agent execution requests"],"output_types":["injected context blocks","augmented agent prompts","context relevance scores","context injection logs"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_6","uri":"capability://safety.moderation.permissions.system.with.sandbox.security.and.capability.isolation","name":"permissions system with sandbox security and capability isolation","description":"Implements a fine-grained permissions system that controls agent access to files, directories, external services, and system capabilities through a declarative permissions configuration. Permissions are defined per agent, per skill, and per resource type (file read/write, network access, command execution), with a sandbox that enforces capability isolation and prevents unauthorized access. The system supports role-based access control (RBAC) and resource-level permissions, enabling secure multi-tenant agent deployments.","intents":["I want to restrict agent access to sensitive files and directories to prevent accidental data exposure","I need to prevent agents from executing arbitrary system commands or making unauthorized network requests","I want to enforce different permission levels for different agents (e.g., read-only for exploratory agents, write access for deployment agents)"],"best_for":["teams deploying Claude Code agents in production with security and compliance requirements","organizations running multi-tenant agent systems where agents must be isolated from each other","developers building agents that interact with sensitive data or critical systems"],"limitations":["Permission enforcement is coarse-grained; no fine-grained row-level or field-level access control for databases","Permissions are static; dynamic permission changes require agent restart or explicit permission refresh","Permission violations are hard-stop; agents terminate when attempting unauthorized access, potentially leaving tasks incomplete","No audit logging of permission checks; difficult to debug permission-related failures or detect unauthorized access attempts"],"requires":["Permissions configuration in CLAUDE.md or settings files","Sandbox runtime that enforces capability isolation (e.g., process-level sandboxing or capability-based security)","Resource access control lists (ACLs) for files, directories, and external services","Permission validation at skill invocation time"],"input_types":["permissions configuration (YAML/JSON)","resource access requests from agents","agent identity and role information","resource metadata (file paths, API endpoints, etc.)"],"output_types":["permission check results (allow/deny)","access control decisions","permission violation errors","audit logs of permission checks"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_7","uri":"capability://automation.workflow.hooks.system.for.lifecycle.event.interception.and.automation","name":"hooks system for lifecycle event interception and automation","description":"Provides a 17+ event-based hook system that intercepts agent lifecycle events (SessionStart, PreToolUse, PostToolUse, Stop, etc.) and enables deterministic automation through hook handlers that can modify agent behavior, log events, or trigger side effects. Hooks are defined as markdown files or code functions, registered per agent or globally, and executed synchronously at specific lifecycle points. The system enables cross-cutting concerns (logging, monitoring, policy enforcement) without modifying agent logic.","intents":["I want to log all agent actions and decisions for audit and debugging purposes without modifying agent code","I need to enforce policies (e.g., rate limiting, permission checks) at specific lifecycle points without hardcoding policy logic into agents","I want to trigger side effects (e.g., notifications, database updates) when agents reach certain milestones or encounter errors"],"best_for":["teams requiring comprehensive audit trails and observability of agent behavior","developers implementing cross-cutting concerns (logging, monitoring, policy enforcement) across multiple agents","organizations with compliance requirements for agent activity tracking and decision logging"],"limitations":["Hooks execute synchronously, blocking agent progress if hook logic is slow; no async hook support or timeout mechanisms","Hook execution order is not guaranteed if multiple hooks are registered for the same event; race conditions possible","Hook failures are fatal; if a hook throws an error, agent execution stops immediately with no fallback or recovery","Limited hook context; hooks receive only event-specific data, not full agent state, making complex decision-making difficult"],"requires":["Hook definitions as markdown files or code functions","Hook registration mechanism (per-agent or global)","Lifecycle event emission from agent runtime","Hook execution engine with error handling"],"input_types":["lifecycle event payloads (event type, agent context, tool info, etc.)","hook handler definitions (markdown or code)","hook configuration (event filters, execution order)"],"output_types":["hook execution results","modified agent behavior (if hook modifies state)","side effects (logs, notifications, database updates)","hook error responses"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_8","uri":"capability://automation.workflow.monorepo.support.with.context.isolation.and.shared.configuration","name":"monorepo support with context isolation and shared configuration","description":"Provides first-class support for monorepo projects where multiple Claude Code agents operate on different packages or services within a single repository. The system enables per-package CLAUDE.md files, isolated agent contexts per package, shared configuration at the monorepo root, and cross-package context references. Agents can operate on specific packages without loading context for unrelated packages, reducing context consumption and preventing cross-package state pollution.","intents":["I want to run different agents on different packages in my monorepo without them interfering with each other","I need to define shared conventions at the monorepo level while allowing package-specific customizations","I want to reduce context consumption by loading only relevant package context instead of the entire monorepo"],"best_for":["teams managing large monorepos with multiple services or packages","organizations using monorepo tools (Nx, Turborepo, Lerna) and wanting Claude Code integration","developers building microservices or modular architectures where agents need package-level isolation"],"limitations":["Context isolation is logical, not enforced; agents can still access files outside their package scope if permissions allow","Cross-package references require explicit configuration; no automatic dependency resolution or context injection","Monorepo structure detection is manual; no automatic package discovery, requiring explicit configuration per package","Shared configuration inheritance is linear; no conditional overrides or environment-specific configurations per package"],"requires":["Monorepo root CLAUDE.md with shared configuration","Per-package CLAUDE.md files in package directories","Package structure metadata (package.json, workspace configuration, etc.)","Monorepo-aware context resolution logic"],"input_types":["monorepo root configuration","per-package CLAUDE.md files","package structure metadata","agent execution requests with package scope"],"output_types":["package-specific context","isolated agent execution environments","cross-package context references","monorepo structure analysis"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-shanraisshan--claude-code-best-practice__cap_9","uri":"capability://planning.reasoning.cross.model.development.workflow.with.plan.mode.and.phase.gated.execution","name":"cross-model development workflow with plan mode and phase-gated execution","description":"Enables development workflows that span multiple Claude models (Claude 3.5 Sonnet for planning, Claude 3 Opus for execution, etc.) with a plan mode that generates structured task plans before execution and phase-gated execution that validates each phase before proceeding. The system uses the Plan agent to decompose complex tasks into phases, validates each phase's output, and gates progression to the next phase based on validation results. This approach reduces hallucination and improves task success rates by separating planning from execution.","intents":["I want to use different Claude models for different stages of task execution (planning vs execution) to optimize cost and quality","I need to validate task progress at each phase before proceeding to the next phase to catch errors early","I want to generate structured task plans that can be reviewed, modified, or executed incrementally"],"best_for":["teams executing complex, multi-step tasks where planning and execution require different model capabilities","developers building agents that need to validate progress and make decisions at phase boundaries","organizations optimizing for cost by using cheaper models for execution after expensive planning"],"limitations":["Plan mode adds latency; generating plans before execution increases total execution time by 20-50%","Phase validation is manual; no automatic validation logic, requiring explicit validation rules per task type","Plan adherence is not enforced; execution agents may deviate from plans without triggering re-planning","Cross-model context transfer is lossy; context generated by one model may not be fully understood by another model"],"requires":["Plan agent implementation (typically Claude 3.5 Sonnet or equivalent)","Execution agent implementation (typically Claude 3 Opus or equivalent)","Phase validation logic (custom per task type)","Structured plan format (JSON or markdown) for inter-model communication"],"input_types":["complex task descriptions","task constraints and requirements","phase validation rules","execution feedback and results"],"output_types":["structured task plans","phase execution results","validation reports","execution logs with phase markers"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":46,"verified":false,"data_access_risk":"high","permissions":["Claude Code environment with .claude/ directory structure support","Markdown-based command definitions in .claude/commands/","Agent type support (general-purpose, Explore, Plan, or custom agent definitions)","Skill definitions with clear input/output contracts","CLAUDE.md file in project root for project-level settings","User config directory (platform-specific: ~/.claude/ on Unix, %APPDATA%/Claude/ on Windows)","Support for environment variable expansion in configuration values","Claude Code CLI with --setting flag support for CLI-level overrides","Scheduling configuration (cron expressions or interval-based)","Task state persistence (file-based or database-backed)"],"failure_modes":["Skill composition adds ~50-100ms per skill invocation due to context switching between isolated execution environments","Lifecycle hooks execute synchronously, blocking agent progress if hook logic is slow; no async hook support","Memory isolation between agents prevents direct cross-agent state sharing; requires explicit message passing or shared storage","Skill reusability depends on careful interface design; tightly coupled skills cannot be reused across different agent types","Settings resolution happens at agent startup; dynamic runtime changes to settings require agent restart","No built-in validation schema for settings; invalid configurations fail silently or at runtime","Environment variable expansion is limited to simple string substitution; no complex templating or computed values","Settings precedence is linear; no conditional logic or context-aware overrides (e.g., different settings per branch)","Scheduling is local to the agent runtime; no distributed scheduling across multiple machines","Task state persistence is not transactional; interrupted tasks may leave partial state that requires manual cleanup","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.8281960973043021,"quality":0.25,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.5,"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":"inactive","updated_at":"2026-05-06T15:12:23.810Z","last_scraped_at":"2026-05-03T13:57:06.483Z","last_commit":"2026-05-02T11:56:42Z"},"community":{"stars":50671,"forks":5037,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=shanraisshan--claude-code-best-practice","compare_url":"https://unfragile.ai/compare?artifact=shanraisshan--claude-code-best-practice"}},"signature":"AxD5ZrGLp6fKUjuEooITR1xmj4fzOD9uJdD5VrMdwRrpgZ++SqAb61dqWb5bcpNDs2nn+tz2MaLNUeB+I4GuBA==","signedAt":"2026-06-21T06:32:57.310Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/shanraisshan--claude-code-best-practice","artifact":"https://unfragile.ai/shanraisshan--claude-code-best-practice","verify":"https://unfragile.ai/api/v1/verify?slug=shanraisshan--claude-code-best-practice","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"}}