claude-code-tutor 1.0.0

package/skills-fallback/cc-mcp-scale-with-mcp-tool-search/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: cc-mcp-scale-with-mcp-tool-search
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Scale with MCP Tool Search
+
+Tool search keeps MCP context usage low by deferring tool definitions until Claude needs them. Only tool names load at session start, so adding more MCP servers has minimal impact on your context window.
+
+### How it works
+
+Tool search is enabled by default. MCP tools are deferred rather than loaded into context upfront, and Claude uses a search tool to discover relevant ones when a task needs them. Only the tools Claude actually uses enter context. From your perspective, MCP tools work exactly as before.
+
+If you prefer threshold-based loading, set `ENABLE_TOOL_SEARCH=auto` to load schemas upfront when they fit within 10% of the context window and defer only the overflow. See [Configure tool search](#configure-tool-search) for all options.
+
+### For MCP server authors
+
+If you're building an MCP server, the server instructions field becomes more useful with Tool Search enabled. Server instructions help Claude understand when to search for your tools, similar to how [skills](/en/skills) work.
+
+Add clear, descriptive server instructions that explain:
+
+- What category of tasks your tools handle
+- When Claude should search for your tools
+- Key capabilities your server provides
+
+Claude Code truncates tool descriptions and server instructions at 2KB each. Keep them concise to avoid truncation, and put critical details near the start.

package/skills-fallback/cc-mcp-use-claude-code-as-an-mcp-server/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: cc-mcp-use-claude-code-as-an-mcp-server
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Use Claude Code as an MCP server
+
+You can use Claude Code itself as an MCP server that other applications can connect to:
+
+```bash theme={null}
+# Start Claude as a stdio MCP server
+claude mcp serve
+```
+
+You can use this in Claude Desktop by adding this configuration to claude\_desktop\_config.json:
+
+```json theme={null}
+{
+  "mcpServers": {
+    "claude-code": {
+      "type": "stdio",
+      "command": "claude",
+      "args": ["mcp", "serve"],
+      "env": {}
+    }
+  }
+}
+```
+
+To find the full path:
+
+```bash theme={null}
+which claude
+```
+
+Then use the full path in your configuration:
+
+```json theme={null}
+{
+  "mcpServers": {
+    "claude-code": {
+      "type": "stdio",
+      "command": "/full/path/to/claude",
+      "args": ["mcp", "serve"],
+      "env": {}
+    }
+  }
+}
+```
+
+Without the correct executable path, you'll encounter errors like `spawn claude ENOENT`.
+
+
+- The server provides access to Claude's tools like View, Edit, LS, etc.
+- In Claude Desktop, try asking Claude to read files in a directory, make edits, and more.
+- Note that this MCP server is only exposing Claude Code's tools to your MCP client, so your own client is responsible for implementing user confirmation for individual tool calls.

package/skills-fallback/cc-mcp-use-mcp-prompts-as-commands/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: cc-mcp-use-mcp-prompts-as-commands
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Use MCP prompts as commands
+
+MCP servers can expose prompts that become available as commands in Claude Code.
+
+### Execute MCP prompts
+
+  <Step title="Execute a prompt without arguments">
+    ```text  theme={null}
+    /mcp__github__list_prs
+    ```
+  </Step>
+
+  <Step title="Execute a prompt with arguments">
+    Many prompts accept arguments. Pass them space-separated after the command:
+
+````
+```text  theme={null}
+/mcp__github__pr_review 456
+```
+
+```text  theme={null}
+/mcp__jira__create_issue "Bug in login flow" high
+```
+````
+
+  </Step>
+</Steps>
+
+- MCP prompts are dynamically discovered from connected servers
+- Arguments are parsed based on the prompt's defined parameters
+- Prompt results are injected directly into the conversation
+- Server and prompt names are normalized (spaces become underscores)

package/skills-fallback/cc-mcp-use-mcp-resources/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: cc-mcp-use-mcp-resources
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Use MCP resources
+
+MCP servers can expose resources that you can reference using @ mentions, similar to how you reference files.
+
+### Reference MCP resources
+
+  <Step title="Reference a specific resource">
+    Use the format `@server:protocol://resource/path` to reference a resource:
+
+````
+```text  theme={null}
+Can you analyze @github:issue://123 and suggest a fix?
+```
+
+```text  theme={null}
+Please review the API documentation at @docs:file://api/authentication
+```
+````
+
+  </Step>
+
+  <Step title="Multiple resource references">
+    You can reference multiple resources in a single prompt:
+
+````
+```text  theme={null}
+Compare @postgres:schema://users with @docs:file://database/user-model
+```
+````
+
+  </Step>
+</Steps>
+
+- Resources are automatically fetched and included as attachments when referenced
+- Resource paths are fuzzy-searchable in the @ mention autocomplete
+- Claude Code automatically provides tools to list and read MCP resources when servers support them
+- Resources can contain any type of content that the MCP server provides (text, JSON, structured data, etc.)

package/skills-fallback/cc-mcp-use-mcp-servers-from-claude-ai/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: cc-mcp-use-mcp-servers-from-claude-ai
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+## Use MCP servers from Claude.ai
+
+If you've logged into Claude Code with a [Claude.ai](https://claude.ai) account, MCP servers you've added in Claude.ai are automatically available in Claude Code:
+
+  <Step title="Authenticate the MCP server">
+    Complete any required authentication steps in Claude.ai.
+  </Step>
+
+  <Step title="View and manage servers in Claude Code">
+    In Claude Code, use the command:
+
+````
+```text  theme={null}
+/mcp
+```
+
+Claude.ai servers appear in the list with indicators showing they come from Claude.ai.
+````
+
+  </Step>
+</Steps>
+
+To disable claude.ai MCP servers in Claude Code, set the `ENABLE_CLAUDEAI_MCP_SERVERS` environment variable to `false`:
+
+```bash theme={null}
+ENABLE_CLAUDEAI_MCP_SERVERS=false claude
+```

package/skills-fallback/cc-mcp-what-you-can-do-with-mcp/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: cc-mcp-what-you-can-do-with-mcp
+description: "Configuración de MCP servers en Claude Code: instalar, scopes (local/project/user), autenticación OAuth, tool search, managed MCP, recursos y prompts MCP."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/mcp.md"
+---
+> ## Documentation Index
+>
+> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
+> Use this file to discover all available pages before exploring further.

package/skills-fallback/cc-memory/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: cc-memory
+description: "CLAUDE.md y auto-memory en Claude Code: dónde poner archivos, import de archivos adicionales, rules directory, gestión para equipos."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/memory.md"
+---
+> ## Documentation Index
+>
+> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# How Claude remembers your project
+
+> Give Claude persistent instructions with CLAUDE.md files, and let Claude accumulate learnings automatically with auto memory.
+
+Each Claude Code session begins with a fresh context window. Two mechanisms carry knowledge across sessions:
+
+- **CLAUDE.md files**: instructions you write to give Claude persistent context
+- **Auto memory**: notes Claude writes itself based on your corrections and preferences
+
+This page covers how to:
+
+- [Write and organize CLAUDE.md files](#claude-md-files)
+- [Scope rules to specific file types](#organize-rules-with-claude/rules/) with `.claude/rules/`
+- [Configure auto memory](#auto-memory) so Claude takes notes automatically
+- [Troubleshoot](#troubleshoot-memory-issues) when instructions aren't being followed

package/skills-fallback/cc-model-config/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: cc-model-config
+description: "Configuración de modelos en Claude Code: aliases (opusplan, fast-mode), restrict model selection, extended context, env vars para pinning."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/model-config.md"
+---
+> ## Documentation Index
+>
+> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Model configuration
+
+> Learn about the Claude Code model configuration, including model aliases like `opusplan`
+
+## Available models
+
+For the `model` setting in Claude Code, you can configure either:
+
+- A **model alias**
+- A **model name**
+  - Anthropic API: A full **[model name](https://platform.claude.com/docs/en/about-claude/models/overview)**
+  - Bedrock: an inference profile ARN
+  - Foundry: a deployment name
+  - Vertex: a version name

package/skills-fallback/cc-permissions/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: cc-permissions
+description: "Sistema de permisos de Claude Code: sintaxis de reglas, modos (auto, plan, bypassPermissions), tool-specific rules, wildcards."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/permissions.md"
+---
+> ## Documentation Index
+>
+> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Configure permissions
+
+> Control what Claude Code can access and do with fine-grained permission rules, modes, and managed policies.
+
+Claude Code supports fine-grained permissions so that you can specify exactly what the agent is allowed to do and what it cannot. Permission settings can be checked into version control and distributed to all developers in your organization, as well as customized by individual developers.
+
+## Permission system
+
+Claude Code uses a tiered permission system to balance power and safety:
+
+| Tool type         | Example          | Approval required | "Yes, don't ask again" behavior               |
+| :---------------- | :--------------- | :---------------- | :-------------------------------------------- |
+| Read-only         | File reads, Grep | No                | N/A                                           |
+| Bash commands     | Shell execution  | Yes               | Permanently per project directory and command |
+| File modification | Edit/write files | Yes               | Until session end                             |
+
+## Manage permissions
+
+You can view and manage Claude Code's tool permissions with `/permissions`. This UI lists all permission rules and the settings.json file they are sourced from.
+
+- **Allow** rules let Claude Code use the specified tool without manual approval.
+- **Ask** rules prompt for confirmation whenever Claude Code tries to use the specified tool.
+- **Deny** rules prevent Claude Code from using the specified tool.
+
+Rules are evaluated in order: **deny -> ask -> allow**. The first matching rule wins, so deny rules always take precedence.

package/skills-fallback/cc-plugins/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: cc-plugins
+description: "Crear plugins para Claude Code: estructura, skills, LSP servers, MCP servers incluidos, distribución en marketplaces."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/plugins.md"
+---
+> ## Documentation Index
+>
+> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Create plugins
+
+> Create custom plugins to extend Claude Code with skills, agents, hooks, and MCP servers.
+
+Plugins let you extend Claude Code with custom functionality that can be shared across projects and teams. This guide covers creating your own plugins with skills, agents, hooks, and MCP servers.
+
+Looking to install existing plugins? See [Discover and install plugins](/en/discover-plugins). For complete technical specifications, see [Plugins reference](/en/plugins-reference).
+
+## When to use plugins vs standalone configuration
+
+Claude Code supports two ways to add custom skills, agents, and hooks:
+
+| Approach                                                    | Skill names          | Best for                                                                                        |
+| :---------------------------------------------------------- | :------------------- | :---------------------------------------------------------------------------------------------- |
+| **Standalone** (`.claude/` directory)                       | `/hello`             | Personal workflows, project-specific customizations, quick experiments                          |
+| **Plugins** (directories with `.claude-plugin/plugin.json`) | `/plugin-name:hello` | Sharing with teammates, distributing to community, versioned releases, reusable across projects |
+
+**Use standalone configuration when**:
+
+- You're customizing Claude Code for a single project
+- The configuration is personal and doesn't need to be shared
+- You're experimenting with skills or hooks before packaging them
+- You want short skill names like `/hello` or `/deploy`
+
+**Use plugins when**:
+
+- You want to share functionality with your team or community
+- You need the same skills/agents across multiple projects
+- You want version control and easy updates for your extensions
+- You're distributing through a marketplace
+- You're okay with namespaced skills like `/my-plugin:hello` (namespacing prevents conflicts between plugins)

package/skills-fallback/cc-sandboxing/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: cc-sandboxing
+description: "Sandboxing en Claude Code: filesystem isolation, network isolation, cómo habilitar, configurar paths permitidos, relación con permisos."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/sandboxing.md"
+---
+> ## Documentation Index
+>
+> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Sandboxing
+
+> Learn how Claude Code's sandboxed bash tool provides filesystem and network isolation for safer, more autonomous agent execution.
+
+## Overview
+
+Claude Code features native sandboxing to provide a more secure environment for agent execution while reducing the need for constant permission prompts. Instead of asking permission for each bash command, sandboxing creates defined boundaries upfront where Claude Code can work more freely with reduced risk.
+
+The sandboxed bash tool uses OS-level primitives to enforce both filesystem and network isolation.

package/skills-fallback/cc-scheduled-tasks/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: cc-scheduled-tasks
+description: "Tareas programadas en Claude Code: /loop, cron syntax, one-time reminders, gestión de tasks recurrentes."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/scheduled-tasks.md"
+---
+> ## Documentation Index
+>
+> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Run prompts on a schedule
+
+> Use /loop and the cron scheduling tools to run prompts repeatedly, poll for status, or set one-time reminders within a Claude Code session.
+
+Scheduled tasks let Claude re-run a prompt automatically on an interval. Use them to poll a deployment, babysit a PR, check back on a long-running build, or remind yourself to do something later in the session. To react to events as they happen instead of polling, see [Channels](/en/channels): your CI can push the failure into the session directly.
+
+Tasks are session-scoped: they live in the current Claude Code process and are gone when you exit. For durable scheduling that survives restarts, use [Cloud](/en/web-scheduled-tasks) or [Desktop](/en/desktop-scheduled-tasks) scheduled tasks, or [GitHub Actions](/en/github-actions).

package/skills-fallback/cc-settings-configuration-scopes/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: cc-settings-configuration-scopes
+description: "Todas las opciones de configuración de Claude Code en settings.json: permisos, hooks, plugins, sandbox, env vars, precedencia de scopes."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/settings.md"
+---
+> ## Documentation Index
+>
+> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Claude Code settings
+
+> Configure Claude Code with global and project-level settings, and environment variables.
+
+Claude Code offers a variety of settings to configure its behavior to meet your needs. You can configure Claude Code by running the `/config` command when using the interactive REPL, which opens a tabbed Settings interface where you can view status information and modify configuration options.
+
+## Configuration scopes
+
+Claude Code uses a **scope system** to determine where configurations apply and who they're shared with. Understanding scopes helps you decide how to configure Claude Code for personal use, team collaboration, or enterprise deployment.
+
+### Available scopes
+
+| Scope       | Location                                                                           | Who it affects                       | Shared with team?      |
+| :---------- | :--------------------------------------------------------------------------------- | :----------------------------------- | :--------------------- |
+| **Managed** | Server-managed settings, plist / registry, or system-level `managed-settings.json` | All users on the machine             | Yes (deployed by IT)   |
+| **User**    | `~/.claude/` directory                                                             | You, across all projects             | No                     |
+| **Project** | `.claude/` in repository                                                           | All collaborators on this repository | Yes (committed to git) |
+| **Local**   | `.claude/settings.local.json`                                                      | You, in this repository only         | No (gitignored)        |
+
+### When to use each scope
+
+**Managed scope** is for:
+
+- Security policies that must be enforced organization-wide
+- Compliance requirements that can't be overridden
+- Standardized configurations deployed by IT/DevOps
+
+**User scope** is best for:
+
+- Personal preferences you want everywhere (themes, editor settings)
+- Tools and plugins you use across all projects
+- API keys and authentication (stored securely)
+
+**Project scope** is best for:
+
+- Team-shared settings (permissions, hooks, MCP servers)
+- Plugins the whole team should have
+- Standardizing tooling across collaborators
+
+**Local scope** is best for:
+
+- Personal overrides for a specific project
+- Testing configurations before sharing with the team
+- Machine-specific settings that won't work for others

package/skills-fallback/cc-settings-environment-variables/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: cc-settings-environment-variables
+description: "Todas las opciones de configuración de Claude Code en settings.json: permisos, hooks, plugins, sandbox, env vars, precedencia de scopes."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/settings.md"
+---
+## Environment variables
+
+Environment variables let you control Claude Code behavior without editing settings files. Any variable can also be configured in [`settings.json`](#available-settings) under the `env` key to apply it to every session or roll it out to your team.
+
+See the [environment variables reference](/en/env-vars) for the full list.

package/skills-fallback/cc-settings-plugin-configuration/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: cc-settings-plugin-configuration
+description: "Todas las opciones de configuración de Claude Code en settings.json: permisos, hooks, plugins, sandbox, env vars, precedencia de scopes."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/settings.md"
+---
+## Plugin configuration
+
+Claude Code supports a plugin system that lets you extend functionality with skills, agents, hooks, and MCP servers. Plugins are distributed through marketplaces and can be configured at both user and repository levels.

package/skills-fallback/cc-settings-see-also/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: cc-settings-see-also
+description: "Todas las opciones de configuración de Claude Code en settings.json: permisos, hooks, plugins, sandbox, env vars, precedencia de scopes."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/settings.md"
+---
+## See also
+
+- [Permissions](/en/permissions): permission system, rule syntax, tool-specific patterns, and managed policies
+- [Authentication](/en/authentication): set up user access to Claude Code
+- [Troubleshooting](/en/troubleshooting): solutions for common configuration issues

package/skills-fallback/cc-settings-settings-files/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: cc-settings-settings-files
+description: "Todas las opciones de configuración de Claude Code en settings.json: permisos, hooks, plugins, sandbox, env vars, precedencia de scopes."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/settings.md"
+---
+## Settings files
+
+The `settings.json` file is the official mechanism for configuring Claude
+Code through hierarchical settings:
+
+- **User settings** are defined in `~/.claude/settings.json` and apply to all
+  projects.
+- **Project settings** are saved in your project directory:
+  - `.claude/settings.json` for settings that are checked into source control and shared with your team
+  - `.claude/settings.local.json` for settings that are not checked in, useful for personal preferences and experimentation. Claude Code will configure git to ignore `.claude/settings.local.json` when it is created.
+- **Managed settings**: For organizations that need centralized control, Claude Code supports multiple delivery mechanisms for managed settings. All use the same JSON format and cannot be overridden by user or project settings:
+
+  - **Server-managed settings**: delivered from Anthropic's servers via the Claude.ai admin console. See [server-managed settings](/en/server-managed-settings).
+  - **MDM/OS-level policies**: delivered through native device management on macOS and Windows:
+    - macOS: `com.anthropic.claudecode` managed preferences domain (deployed via configuration profiles in Jamf, Kandji, or other MDM tools)
+    - Windows: `HKLM\SOFTWARE\Policies\ClaudeCode` registry key with a `Settings` value (REG\_SZ or REG\_EXPAND\_SZ) containing JSON (deployed via Group Policy or Intune)
+    - Windows (user-level): `HKCU\SOFTWARE\Policies\ClaudeCode` (lowest policy priority, only used when no admin-level source exists)
+  - **File-based**: `managed-settings.json` and `managed-mcp.json` deployed to system directories:
+
+    - macOS: `/Library/Application Support/ClaudeCode/`
+    - Linux and WSL: `/etc/claude-code/`
+    - Windows: `C:\Program Files\ClaudeCode\`
+
+    File-based managed settings also support a drop-in directory at `managed-settings.d/` in the same system directory alongside `managed-settings.json`. This lets separate teams deploy independent policy fragments without coordinating edits to a single file.
+
+    Following the systemd convention, `managed-settings.json` is merged first as the base, then all `*.json` files in the drop-in directory are sorted alphabetically and merged on top. Later files override earlier ones for scalar values; arrays are concatenated and de-duplicated; objects are deep-merged. Hidden files starting with `.` are ignored.
+
+    Use numeric prefixes to control merge order, for example `10-telemetry.json` and `20-security.json`.
+
+  See [managed settings](/en/permissions#managed-only-settings) and [Managed MCP configuration](/en/mcp#managed-mcp-configuration) for details.

package/skills-fallback/cc-settings-subagent-configuration/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: cc-settings-subagent-configuration
+description: "Todas las opciones de configuración de Claude Code en settings.json: permisos, hooks, plugins, sandbox, env vars, precedencia de scopes."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/settings.md"
+---
+## Subagent configuration
+
+Claude Code supports custom AI subagents that can be configured at both user and project levels. These subagents are stored as Markdown files with YAML frontmatter:
+
+- **User subagents**: `~/.claude/agents/` - Available across all your projects
+- **Project subagents**: `.claude/agents/` - Specific to your project and can be shared with your team
+
+Subagent files define specialized AI assistants with custom prompts and tool permissions. Learn more about creating and using subagents in the [subagents documentation](/en/sub-agents).

package/skills-fallback/cc-settings-tools-available-to-claude/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: cc-settings-tools-available-to-claude
+description: "Todas las opciones de configuración de Claude Code en settings.json: permisos, hooks, plugins, sandbox, env vars, precedencia de scopes."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/settings.md"
+---
+## Tools available to Claude
+
+Claude Code has access to a set of tools for reading, editing, searching, running commands, and orchestrating subagents. Tool names are the exact strings you use in permission rules and hook matchers.
+
+See the [tools reference](/en/tools-reference) for the full list and Bash tool behavior details.

package/skills-fallback/cc-skills-guide/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: cc-skills-guide
+description: "Cómo crear y configurar Skills en Claude Code: frontmatter, invocation control, subagent skills, path-specific, bundled skills."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/skills.md"
+---
+> ## Documentation Index
+>
+> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Extend Claude with skills
+
+> Create, manage, and share skills to extend Claude's capabilities in Claude Code. Includes custom commands and bundled skills.
+
+Skills extend what Claude can do. Create a `SKILL.md` file with instructions, and Claude adds it to its toolkit. Claude uses skills when relevant, or you can invoke one directly with `/skill-name`.
+
+**Custom commands have been merged into skills.** A file at `.claude/commands/deploy.md` and a skill at `.claude/skills/deploy/SKILL.md` both create `/deploy` and work the same way. Your existing `.claude/commands/` files keep working. Skills add optional features: a directory for supporting files, frontmatter to [control whether you or Claude invokes them](#control-who-invokes-a-skill), and the ability for Claude to load them automatically when relevant.
+
+
+Claude Code skills follow the [Agent Skills](https://agentskills.io) open standard, which works across multiple AI tools. Claude Code extends the standard with additional features like [invocation control](#control-who-invokes-a-skill), [subagent execution](#run-skills-in-a-subagent), and [dynamic context injection](#inject-dynamic-context).

package/skills-fallback/cc-sub-agents/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: cc-sub-agents
+description: "Configuración de sub-agents en Claude Code: frontmatter fields, modelos, tools disponibles, persistent memory, hooks en subagents."
+invocation: auto
+_pulse: true
+_syncedAt: "2026-04-07T04:44:06.766Z"
+_source: "https://code.claude.com/docs/en/sub-agents.md"
+---
+> ## Documentation Index
+>
+> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Create custom subagents
+
+> Create and use specialized AI subagents in Claude Code for task-specific workflows and improved context management.
+
+Subagents are specialized AI assistants that handle specific types of tasks. Each subagent runs in its own context window with a custom system prompt, specific tool access, and independent permissions. When Claude encounters a task that matches a subagent's description, it delegates to that subagent, which works independently and returns results. To see the context savings in practice, the [context window visualization](/en/context-window) walks through a session where a subagent handles research in its own separate window.
+
+Subagents help you:
+
+- **Preserve context** by keeping exploration and implementation out of your main conversation
+- **Enforce constraints** by limiting which tools a subagent can use
+- **Reuse configurations** across projects with user-level subagents
+- **Specialize behavior** with focused system prompts for specific domains
+- **Control costs** by routing tasks to faster, cheaper models like Haiku
+
+Claude uses each subagent's description to decide when to delegate tasks. When you create a subagent, write a clear description so Claude knows when to use it.
+
+Claude Code includes several built-in subagents like **Explore**, **Plan**, and **general-purpose**. You can also create custom subagents to handle specific tasks. This page covers the [built-in subagents](#built-in-subagents), [how to create your own](#quickstart-create-your-first-subagent), [full configuration options](#configure-subagents), [patterns for working with subagents](#work-with-subagents), and [example subagents](#example-subagents).