mirror of
https://github.com/kamranahmedse/developer-roadmap.git
synced 2026-03-12 17:51:53 +08:00
chore: sync content to repo (#9658)
Co-authored-by: kamranahmedse <4921183+kamranahmedse@users.noreply.github.com>
This commit is contained in:
github-actions[bot]
committed by
GitHub
GitHub
parent
e15a0e3330
commit
4c6625bb4f
@@ -1,6 +1,6 @@
|
||||
# Agent Team
|
||||
|
||||
Agent Teams are an experimental multi-agent orchestration feature in Claude Code that allows you to coordinate multiple AI instances working in parallel on a single project. Unlike standard subagents, which operate in silos and only report back to a parent, Agent Teams function as a collaborative network where a designated Team Lead manages a shared task list and delegates work to Teammates who can message each other directly to share findings or debate solutions. This approach is specifically designed to handle "wide" tasks—such as simultaneous cross-layer feature development (frontend, backend, and tests) or deep debugging where different agents test competing hypotheses—by giving each agent its own independent context window to prevent token bloat in the main session.
|
||||
Agent Teams are an experimental multi-agent orchestration feature in Claude Code that allows you to coordinate multiple AI instances working in parallel on a single project. Agent Teams function as a collaborative network where a designated Team Lead manages a shared task list and delegates work to Teammates who can message each other directly to share findings or debate solutions.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Be mindful of extensions
|
||||
|
||||
Carefully managing extensions—such as MCP servers, skills, and subagents—is vital because every active integration consumes a portion of Claude’s finite context window, and excessive "context pollution" can lead to degraded reasoning or higher operational costs. While global extensions provide broad utility, they are re-read during every interaction; therefore, it is a best practice to use "lazy loading" by keeping specialized instructions in subdirectory [CLAUDE.md](http://CLAUDE.md) files or on-demand skills that only enter the context when specifically triggered. For high-volume tasks like log analysis or extensive file searches, you should offload the work to subagents, which operate in an isolated context window and return only a concise summary to your main session, effectively shielding your primary conversation from token bloat. By intentionally scoping your tools and disabling those not needed for your current task, you preserve the high-quality "reasoning core" of the model, ensure that critical instructions aren't "lost in the middle," and maximize the value of features like prompt caching to keep your development cycles fast and cost-effective.
|
||||
Carefully managing extensions, such as MCP servers, skills, and subagents, is vital because every active integration consumes a portion of Claude’s finite context window, and excessive "context pollution" can lead to degraded reasoning or higher operational costs.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -5,4 +5,4 @@ The `claude --add-dir` command is a startup flag that allows you to include extr
|
||||
Visit the following resources to learn more:
|
||||
|
||||
- [@official@CLI flags](https://code.claude.com/docs/en/cli-reference#cli-flags)
|
||||
- [@official@Load memory from additional directories](https://code.claude.com/docs/en/memory#load-memory-from-additional-directories)
|
||||
- [@official@Load memory from additional directories](https://code.claude.com/docs/en/memory#load-memory-from-additional-directories)
|
||||
@@ -1,6 +1,6 @@
|
||||
# Claude CLI
|
||||
|
||||
Claude Code CLI is a command-line tool that acts as an agentic AI coding partner by interacting directly with your local files and terminal. To set it up, you first need an active Claude subscription or an Anthropic Console account. On macOS or Linux, you can install it by running a simple command in your terminal (curl -fsSL [https://claude.ai/install.sh](https://claude.ai/install.sh) | bash), while Windows users can use PowerShell (irm [https://claude.ai/install.ps1](https://claude.ai/install.ps1) | iex). Once installed, navigate to your project folder, type claude to start a session, and follow the prompts to log in via your browser. From there, you can ask questions or give instructions, and the assistant will propose specific code changes for you to review and approve
|
||||
Claude Code CLI is a command-line tool that acts as an agentic AI coding partner by interacting directly with your local files and terminal. To set it up, you first need an active Claude subscription or an Anthropic Console account. Once installed, navigate to your project folder, type `claude` to start a session, and follow the prompts to log in via your browser.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# CLAUDE.md
|
||||
|
||||
`CLAUDE.md` is a configuration file placed in a project's root directory that provides the AI assistant with specific rules, project context, and custom instructions for that particular codebase. It acts as a set of persistent guidelines that the AI reads at the start of every session to ensure its code suggestions align with your project's coding standards, tech stack, and architectural patterns. By defining your preferred naming conventions, testing frameworks, or known edge cases within this file, you can maintain consistency across a team and prevent the assistant from making repetitive mistakes. This file is particularly useful for documenting complex workflows or "gotchas" that are unique to your local environment, effectively acting as a specialized instruction manual for the AI.
|
||||
`CLAUDE.md` is a configuration file placed in a project's root directory that provides the AI assistant with specific rules, project context, and custom instructions for that particular codebase. It acts as a set of persistent guidelines that the AI reads at the start of every session to ensure its code suggestions align with your project's coding standards, tech stack, and architectural patterns.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# CLAUDE.md
|
||||
|
||||
[CLAUDE.md](http://CLAUDE.md) is a project-specific markdown file that acts as the "persistent memory" and onboarding manual for Claude Code, ensuring the AI adheres to your unique development standards across every session. Since Claude begins each new interaction with a blank context, this file is automatically read at launch to provide essential project "WHY, WHAT, and HOW"—including your tech stack, directory structure, preferred coding patterns (e.g., "Use functional React components"), and exact shell commands for building or testing. By maintaining this document in your project root or `.claude/` directory, you eliminate the need to repeat basic instructions in your prompts, significantly reduce "hallucinations" or stylistic drift, and keep the AI aligned with your team's specific conventions. You can quickly bootstrap a custom version by running the `/init` command, which analyzes your repository to detect frameworks and suggest a baseline configuration.
|
||||
CLAUDE.md is a project-specific markdown file that acts as the "persistent memory" and onboarding manual for Claude Code, ensuring the AI adheres to your unique development standards across every session. Since Claude begins each new interaction with a blank context, this file is automatically read at launch to provide essential project "WHY, WHAT, and HOW".
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Code Intelligence Plugin
|
||||
|
||||
In Claude Code, Code Intelligence plugins extend the CLI's native search capabilities by integrating with the Language Server Protocol (LSP), granting Claude the same "IDE-level" awareness found in modern editors. By installing language-specific plugins via the `/plugin` command, you enable Claude to perform high-precision navigation—including jumping to definitions, finding references, and listing symbols—rather than relying solely on keyword-based grep searches. These plugins also provide instant diagnostics, allowing Claude to detect and fix type errors or syntax warnings immediately after an edit is made.
|
||||
Code Intelligence plugins extend the CLI's native search capabilities by integrating with the Language Server Protocol (LSP), granting Claude the same "IDE-level" awareness found in modern editors.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Community Tools
|
||||
|
||||
Community tools extend the capabilities of Claude Code by integrating it with external platforms through the Model Context Protocol (MCP) and specialized plugins. These integrations allow the assistant to interact directly with services like GitHub for managing pull requests, Slack for sending project updates, and Jira or Linear for tracking issues. Beyond official offerings, the community has developed numerous third-party extensions—such as Claude Trace for observability and Gemini CLI for cross-model reviews—which can be easily added via the `/plugin` command to tailor the assistant's skills to your specific team’s tech stack and workflow.
|
||||
Community tools extend the capabilities of Claude Code by integrating it with external platforms through the Model Context Protocol (MCP) and specialized plugins. These integrations allow the assistant to interact directly with services like GitHub for managing pull requests, Slack for sending project updates, and Jira or Linear for tracking issues. Beyond official offerings, the community has developed numerous third-party extensions, which can be easily added via the `/plugin` command.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
# Connecting Tools with MCP
|
||||
|
||||
Model Context Protocol (MCP) transforms Claude Code from a local file editor into a connected agent capable of interacting with your entire tech stack, from Jira tickets to live databases. Acting like a "USB-C port for AI," MCP provides a standardized bridge that allows Claude to discover and execute external functions without requiring custom-coded integrations for every service. You can add these capabilities using the interactive `claude mcp add` command or by directly editing your configuration file. This modularity is key to managing your context window; rather than loading every possible tool at once, you can scope specific MCP servers to individual projects or call them on-demand, ensuring Claude has the exact "hands" it needs only when the task requires them.
|
||||
Model Context Protocol (MCP) transforms Claude Code from a local file editor into a connected agent capable of interacting with your entire tech stack, from Jira tickets to live databases. Acting like a "USB-C port for AI," MCP provides a standardized bridge that allows Claude to discover and execute external functions without requiring custom-coded integrations for every service.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
- [@official@Connect Claude Code to tools via MCP](https://code.claude.com/docs/en/mcp)
|
||||
- [@course@Model Context Protocol: Advanced Topics](https://anthropic.skilljar.com/model-context-protocol-advanced-topics)
|
||||
- [@article@What is the Model Context Protocol (MCP)?](https://modelcontextprotocol.io/docs/getting-started/intro)
|
||||
- [@video@Claude Code MCP: How to Add MCP Servers (Complete Guide)](https://www.youtube.com/watch?v=DfWHX7kszQI)
|
||||
- [@video@Claude Code Tutorial #7 - MCP Servers](https://www.youtube.com/watch?v=X7lgIa6guKg)
|
||||
@@ -1,6 +1,6 @@
|
||||
# Creating Custom Skills
|
||||
|
||||
To create a custom skill in Claude Code, you must establish a new folder within the `.claude/skills/` directory containing a `SKILL.md` file that defines the skill's identity and logic. This file begins with a YAML frontmatter block containing a unique `name` and a detailed `description`—which Claude uses as a trigger to "know" when to activate the skill—and can include an optional `disable-model-invocation: true` flag if you want the skill to run as a manual, deterministic workflow rather than an autonomous one. The body of the Markdown file acts as a specialized system prompt, where you provide step-by-step instructions, define argument placeholders like `$ARGUMENTS`, and list the specific tool sequences Claude should follow to complete the task. By organizing your skill this way, you allow Claude to maintain a lean context window, loading these expert instructions only when you explicitly call them via a slash command (e.g., `/my-skill-name`) or when Claude Code detects a task that matches the skill’s documented purpose.
|
||||
To create a custom skill in Claude Code, you must establish a new folder within the `.claude/skills/` directory containing a `SKILL.md` file that defines the skill's identity and logic. This file begins with a YAML frontmatter block containing a unique `name` and a detailed `description`, which Claude uses as a trigger to "know" when to activate the skill, and can include an optional `disable-model-invocation: true` flag if you want the skill to run as a manual, deterministic workflow rather than an autonomous one.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Creating Subagents
|
||||
|
||||
To create a Subagent in Claude Code, you must define a specialized assistant within a Markdown file located in the `.claude/agents/` directory, using YAML frontmatter to specify its `name`, `description`, `model`, and a restricted set of `tools`. This isolated architecture is most effective when you need to delegate "high-context" tasks—like searching through dozens of files for architectural patterns or performing a security audit—because the subagent operates in its own context window, returning only a summarized result to your main session to save tokens and prevent "distraction." For best results, use a descriptive trigger in the YAML header so the main agent knows when to autonomously invoke it, and strictly limit the subagent's tools (e.g., providing only `Read` and `Grep` for a "Reviewer" agent) to create a safe, read-only layer of expertise. You can also optimize for cost by assigning Claude Haiku to simple subagent tasks like linting, while reserving sonnet for the main reasoning loop.
|
||||
To create a Subagent in Claude Code, you must define a specialized assistant within a Markdown file located in the `.claude/agents/` directory, using YAML frontmatter to specify its `name`, `description`, `model`, and a restricted set of `tools`.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Customize Status Line
|
||||
|
||||
Claude Code allows you to personalize your terminal environment by customizing the status line, which is the persistent information bar at the bottom of the interface. This feature functions as a dynamic dashboard that receives a real-time JSON payload containing metadata—such as your active Git branch, the model in use, and critical context window metrics—and processes it through a script to display custom text or emojis. You can quickly configure a preset using the `/statusline` command or achieve deep customization by pointing the statusLine configuration in your `settings.json` to a custom shell script that parses inputs. By tailoring this bar, you can keep essential data like real-time session costs or context usage percentages visible at all times, helping you manage your budget and "context rot" without manually running diagnostic commands.
|
||||
Claude Code allows you to personalize your terminal environment by customizing the status line, which is the persistent information bar at the bottom of the interface. You can keep essential data like real-time session costs or context usage percentages visible at all times, helping you manage your budget and "context rot" without manually running diagnostic commands.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Claude Code Desktop
|
||||
|
||||
Claude Code desktop is a software application that allows an AI assistant to interact directly with your local files and development tools through a graphical interface. It functions as an agentic coding partner that can read your codebase, edit files, and execute terminal commands to help build features or fix bugs in real time. The app organizes your work into a "Code" tab for direct project interaction and a "Cowork" tab for autonomous background tasks, while also offering a familiar chat interface for general questions.
|
||||
Claude Code desktop is a software application that allows an AI assistant to interact directly with your local files and development tools through a graphical interface. It functions as an agentic coding partner that can read your codebase, edit files, and execute terminal commands to help build features or fix bugs in real time.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Haiku
|
||||
|
||||
Claude Haiku is the fastest and most cost-effective model in the Claude family, specifically engineered for high-speed, high-volume tasks that require near-instant responsiveness. It provides a compact but powerful solution for real-time applications like customer service chatbots, rapid data extraction, and moderating large content streams where low latency is critical. Despite its smaller size, it includes advanced features such as extended thinking, a large token context window, and sophisticated vision capabilities for analyzing charts and diagrams. In complex development environments, it is frequently used as a "sub-agent" to handle repetitive background operations—like scanning logs, generating documentation, or running quick tests—allowing larger models to focus on more difficult architectural problems without slowing down the overall workflow.
|
||||
Claude Haiku is the fastest and most cost-effective model in the Claude family, specifically engineered for high-speed, high-volume tasks that require near-instant responsiveness. It provides a compact but powerful solution for real-time applications like customer service chatbots, rapid data extraction, and moderating large content streams where low latency is critical.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Headless mode
|
||||
|
||||
Headless mode in Claude Code, enabled by the `-p` (or `--print`) flag, transforms the interactive terminal assistant into a programmable Unix-style utility designed for automation and CI/CD pipelines. In this mode, Claude executes a single prompt non-interactively, printing its response directly to `stdout` before exiting, which allows you to pipe data into the agent (e.g., `cat logs.txt | claude -p "Find errors"`) or chain its output into other tools like `jq` or `grep`. While powerful for batch processing and automated code reviews, headless mode requires strict permission scoping—often using `--dangerously-skip-permissions` in isolated CI containers—to prevent the AI from performing unauthorized system actions without human oversight.
|
||||
Headless mode in Claude Code, enabled by the `-p` (or `--print`) flag, transforms the interactive terminal assistant into a programmable Unix-style utility designed for automation and CI/CD pipelines.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Hook Events & Matchers
|
||||
|
||||
In Claude Code, Hook Events represent the specific lifecycle moments when custom logic can be triggered, while Matchers act as the regex-based filters that determine which specific actions within those moments should fire the hook. Events cover every phase of the agentic loop, from session initialization (`SessionStart`) and user input (`UserPromptSubmit`) to the execution gates before and after a tool is used (`PreToolUse` and `PostToolUse`). Matchers are primarily used with tool-based events to target specific capabilities; for example, a matcher of `Bash` targets shell commands, while `Edit|Write` targets file modifications. If a matcher is omitted or set to `*`, the hook triggers for every occurrence of that event. By combining these, you can create precise guardrails—such as a `PreToolUse` hook with a `Bash` matcher to block `rm -rf` commands, or a `PostToolUse` hook with an `Edit` matcher to auto-format code only after a file has been modified—ensuring that your automation is both powerful and token-efficient.
|
||||
In Claude Code, Hook Events represent the specific lifecycle moments when custom logic can be triggered, while Matchers act as the regex-based filters that determine which specific actions within those moments should fire the hook.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Hook Inputs & Outputs
|
||||
|
||||
In Claude Code, hooks communicate via a standardized JSON interface: Inputs are passed to the hook via `stdin`, and Outputs are returned via `stdout` to influence the agent's next move. The input payload typically includes a `context` object containing session metadata and event-specific data, such as the `tool` name and its arguments (e.g., the exact code being written or command being run). To respond, your hook must return a JSON object. For Command hooks, an exit code of `0` allows the action to proceed, while an exit code of `2` paired with a "reason" string in the output JSON blocks the tool and reports the failure back to Claude.
|
||||
Hooks communicate via a standardized JSON interface: Inputs are passed to the hook via `stdin`, and Outputs are returned via `stdout` to influence the agent's next move. The input payload typically includes a `context` object containing session metadata and event-specific data, such as the `tool` name and its arguments (e.g., the exact code being written or command being run). To respond, your hook must return a JSON object.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Hook Types
|
||||
|
||||
In Claude Code, you can configure three distinct handler types for your hooks—Command, Prompt, and Agent—depending on whether you need a script, an AI "judgement call," or a specialized researcher to validate actions. Command hooks (`type: "command"`) are deterministic shell scripts that execute standard commands (like `npm run lint`) and use exit codes to either approve the action or block it with an error message. Prompt hooks (`type: "prompt"`) use a lightweight Claude model for single-turn evaluation, where the model analyzes the context (e.g., "Is this commit message descriptive?") and returns a simple JSON yes/no decision. Finally, Agent hooks (`type: "agent"`) are the most sophisticated, spawning a multi-turn subagent with tool access (like `Read` or `Grep`) to conduct deep, autonomous verification before deciding if the main agent should proceed. By layering these—such as using a fast Command hook for syntax and a Prompt hook for style—you create a robust, automated guardrail system that balances speed with intelligent oversight.
|
||||
In Claude Code, you can configure three distinct handler types for your hooks—Command, Prompt, and Agent—depending on whether you need a script, an AI "judgement call," or a specialized researcher to validate actions. Command hooks (`type: "command"`) are deterministic shell scripts that execute standard commands (like `npm run lint`) and use exit codes to either approve the action or block it with an error message. Prompt hooks (`type: "prompt"`) use a lightweight Claude model for single-turn evaluation, where the model analyzes the context (e.g., "Is this commit message descriptive?") and returns a simple JSON yes/no decision. Finally, Agent hooks (`type: "agent"`) are the most sophisticated, spawning a multi-turn subagent with tool access (like `Read` or `Grep`) to conduct deep, autonomous verification before deciding if the main agent should proceed.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Hooks
|
||||
|
||||
Hooks are automated triggers that execute specific scripts or commands at key points in the AI's workflow, such as before or after the assistant performs a task. These hooks allow developers to enforce project standards and ensure system reliability without manual intervention, much like Git hooks but designed for an AI-driven development cycle. For example, a "pre-edit" hook can automatically back up a file before the AI touches it, while a "post-task" hook can trigger a code formatter or run a specific test suite to verify that the AI's changes didn't break anything. By configuring these in your project's settings, you create a safety net that ensures the AI assistant remains compliant with your local environment's rules and development lifecycle every time it operates.
|
||||
Hooks are automated triggers that execute specific scripts or commands at key points in the AI's workflow, such as before or after the assistant performs a task. These hooks allow developers to enforce project standards and ensure system reliability without manual intervention, much like Git hooks but designed for an AI-driven development cycle.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Hooks
|
||||
|
||||
Hooks are automated triggers that execute specific scripts or commands at key points in the AI's workflow, such as before or after the assistant performs a task. These hooks allow developers to enforce project standards and ensure system reliability without manual intervention, much like Git hooks but designed for an AI-driven development cycle. For example, a "pre-edit" hook can automatically back up a file before the AI touches it, while a "post-task" hook can trigger a code formatter or run a specific test suite to verify that the AI's changes didn't break anything. By configuring these in your project's settings, you create a safety net that ensures the AI assistant remains compliant with your local environment's rules and development lifecycle every time it operates.
|
||||
Hooks are automated triggers that execute specific scripts or commands at key points in the AI's workflow, such as before or after the assistant performs a task. These hooks allow developers to enforce project standards and ensure system reliability without manual intervention, much like Git hooks but designed for an AI-driven development cycle.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# How to Structure CLAUDE.md
|
||||
|
||||
To write an effective [CLAUDE.md](http://CLAUDE.md), you should treat it as a concise, persistent "source of truth" that provides Claude with the project-specific context it cannot infer from the code alone. According to the official best practices, the file should be kept short and human-readable, focusing on non-obvious information like unique bash commands for building and testing, repository-specific code styles (e.g., "Use ES modules, not CommonJS"), and architectural decisions. You should strictly exclude anything Claude can figure out by reading the code, standard language conventions, or self-evident advice like "write clean code," as a bloated file causes the model to ignore your actual instructions. Structure the document with clear headings and use the `@path/to/file` syntax to import external documentation (like `README.md` or `package.json`) to keep the core [CLAUDE.md](http://CLAUDE.md) lean. Treat the file like code: refine it over time using the `/init` command to bootstrap a version, prune it regularly to ensure high adherence, and commit it to Git, so your entire team benefits from the shared context.
|
||||
To write an effective CLAUDE.md, you should treat it as a concise, persistent "source of truth" that provides Claude with the project-specific context it cannot infer from the code alone. The file should be kept short and human-readable, focusing on non-obvious information like unique bash commands for building and testing, repository-specific code styles, and architectural decisions.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Locations of CLAUDE.md
|
||||
|
||||
Claude Code manages instructions through a hierarchical memory system that layers context based on the directory structure of your project. At the start of every session, Claude recursively searches from your current working directory up to the root, automatically loading global preferences from `~/.claude/CLAUDE.md` and shared team standards from the project root's `CLAUDE.md`. While these high-level rules establish the "WHY" and "HOW" for the entire codebase, Claude also supports progressive disclosure via subdirectory [CLAUDE.md](http://CLAUDE.md) files; these are loaded on demand only when Claude reads a file within that specific folder (e.g., `./src/api/CLAUDE.md`). This location-based behavior prevents "context bloat" by ensuring specialized rules—like specific API middleware requirements or frontend styling—only occupy the context window when they are relevant to the task at hand. By strategically placing instructions closer to the code they govern, you maintain a sharper, more token-efficient model that prioritizes local conventions over global defaults without losing sight of the project's overall architecture.
|
||||
Claude Code manages instructions through a hierarchical memory system that layers context based on the directory structure of your project. At the start of every session, Claude recursively searches from your current working directory up to the root, automatically loading global preferences from `~/.claude/CLAUDE.md` and shared team standards from the project root's `CLAUDE.md`. Claude also supports progressive disclosure via subdirectory CLAUDE.md files.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Manage Sessions
|
||||
|
||||
Claude Code manages sessions through a persistent, local architecture where every interaction is stored in a unique session file, allowing you to resume work using terminal flags like `claude --continue` (for the most recent thread) or `claude --resume` (to open an interactive picker of past conversations). While each new session initializes with a fresh context window to optimize token usage and avoid irrelevance, Claude automatically snapshots affected files before any modification, enabling you to use the `/rewind` command to revert both code and conversation history to a previous "checkpoint." If you want to explore a different implementation path without altering your original work, you can use `claude --continue --fork-session` to branch into a new session ID that inherits all current context.
|
||||
Claude Code manages sessions through a persistent, local architecture where every interaction is stored in a unique session file, allowing you to resume work using terminal flags like `claude --continue` (for the most recent thread) or `claude --resume` (to open an interactive picker of past conversations). While each new session initializes with a fresh context window to optimize token usage and avoid irrelevance, Claude automatically snapshots affected files before any modification, enabling you to use the `/rewind` command to revert both code and conversation history to a previous "checkpoint."
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -5,6 +5,7 @@ The Model Context Protocol (MCP) is an open-source standard that enables a Claud
|
||||
Visit the following resources to learn more:
|
||||
|
||||
- [@official@Connect Claude Code to tools via MCP - Claude Code Docs](https://code.claude.com/docs/en/mcp)
|
||||
- [@course@Introduction to Model Context Protocol](https://anthropic.skilljar.com/introduction-to-model-context-protocol)
|
||||
- [@article@What is the Model Context Protocol (MCP)?](https://modelcontextprotocol.io/docs/getting-started/intro)
|
||||
- [@video@Claude Code Tutorial #7 - MCP Servers](https://www.youtube.com/watch?v=X7lgIa6guKg)
|
||||
- [@video@Claude Code MCP: How to Add MCP Servers (Complete Guide)](https://www.youtube.com/watch?v=DfWHX7kszQI)
|
||||
@@ -1,6 +1,6 @@
|
||||
# Opus
|
||||
|
||||
Claude Opus is the most advanced and capable large language model in the Claude family, designed specifically for high-level reasoning and complex problem-solving. It functions as a "deep thinking" engine that can handle vast amounts of information and follow intricate instructions with a high degree of accuracy and nuance. In technical environments, it is typically used for architectural design, surgical bug fixes in large codebases, and strategic planning, where a mistake could lead to significant system failures. While it is slower and more resource-intensive than smaller models, its superior logic allows it to solve "hard" problems that require a holistic understanding of a project's context and long-term goals.
|
||||
Claude Opus is the most advanced and capable large language model in the Claude family, designed specifically for high-level reasoning and complex problem-solving. It functions as a "deep thinking" engine that can handle vast amounts of information and follow intricate instructions with a high degree of accuracy and nuance.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Opusplan
|
||||
|
||||
`opusplan` is a specialized command alias for Claude Code that combines the high-level reasoning of the most advanced model with the speed and efficiency of a faster one to optimize complex development tasks. When you initiate a session using `claude opusplan`, the tool uses Claude Opus to analyze your request, explore the codebase, and draft a comprehensive technical strategy, ensuring that the initial logic and architectural decisions are as accurate as possible. Once the plan is finalized, the system automatically hands off the execution phase to Claude Sonnet, who carries out the actual file edits, terminal commands, and test runs. This workflow is commonly used for large-scale refactors, implementing features across multiple files, or solving "hard" bugs where the risk of logic errors is high, as it provides the intelligence of a top-tier model while significantly reducing the time and cost compared to using Opus for the entire coding process.
|
||||
`opusplan` is a specialized command alias for Claude Code that combines the high-level reasoning of the most advanced model with the speed and efficiency of a faster one to optimize complex development tasks. When you initiate a session using `claude opusplan`, the tool uses Claude Opus to analyze your request, explore the codebase, and draft a comprehensive technical strategy, ensuring that the initial logic and architectural decisions are as accurate as possible.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Output Styles
|
||||
|
||||
Claude Code allows you to switch between different output styles to adapt the agent’s persona and verbosity to your specific needs, effectively modifying its core system prompt. Beyond the standard coding mode, you can use built-in styles like Explanatory, which provides educational insights into implementation choices, or Learning, a collaborative mode where Claude places `TODO(human)` markers to encourage hands-on contribution. You can toggle these via the `/output-style` command or create custom output styles by placing Markdown files with YAML frontmatter in your `.claude/output-styles` directory, allowing you to define entirely new behaviors or specialized non-engineering personas.
|
||||
Claude Code allows you to switch between different output styles to adapt the agent’s persona and verbosity to your specific needs, effectively modifying its core system prompt. Beyond the standard coding mode, you can use built-in styles like Explanatory, which provides educational insights into implementation choices, or Learning, a collaborative mode where Claude places `TODO(human)` markers to encourage hands-on contribution.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Permission Modes
|
||||
|
||||
Claude Code features several permission modes that define the balance between autonomy and safety during your session, ranging from Plan mode, which restricts Claude to a read-only state for exploration and strategy without any tool execution, to BypassPermissions mode (often called "YOLO mode"), which grants the AI full autonomy to run any command or edit any file without interruption. Between these extremes, Default mode maintains a "human-in-the-loop" approach by requiring manual approval for initial tool uses or sensitive bash commands, while AcceptEdits mode (displayed as Delegate mode in some CLI versions) streamlines development by auto-approving file modifications while still prompting you for potentially destructive terminal actions. You can cycle through these modes in real-time by pressing `Shift+Tab` or set a starting point using the `—permission-mode` flag, ensuring you can scale the AI's power to match your trust level in a specific project or environment.
|
||||
Claude Code features several permission modes that define the balance between autonomy and safety during your session, ranging from Plan mode, which restricts Claude to a read-only state for exploration and strategy without any tool execution, to BypassPermissions mode (often called "YOLO mode"), which grants the AI full autonomy to run any command or edit any file without interruption.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Plan Mode
|
||||
|
||||
Plan Mode is a strictly read-only permission state that allows Claude to analyze your codebase, research dependencies, and draft a step-by-step implementation strategy without the risk of modifying any files or executing state-changing commands. It is essentially an "architectural phase" where Claude uses search and analysis tools to build a deep mental model of your project, culminating in a detailed plan for your review before a single line of code is written. You can access the plan by typing `Ctrl+G`. You should use Plan Mode when tackling complex refactors, exploring unfamiliar repositories, or designing new features with multiple moving parts, as it forces a "think-before-you-act" workflow that prevents costly mistakes and ensures the AI fully understands the project's constraints.
|
||||
Plan Mode is a strictly read-only permission state that allows Claude to analyze your codebase, research dependencies, and draft a step-by-step implementation strategy without the risk of modifying any files or executing state-changing commands.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Plugins
|
||||
|
||||
Claude Code plugins are shareable packages that bundle multiple customizations—including slash commands, specialized agents, skills, hooks, and Model Context Protocol (MCP) servers—into a single installable unit. They serve as a standardized way to distribute complex AI workflows across different projects or within an engineering team, ensuring that every developer has access to the same tools and coding standards. Each plugin is organized around a `plugin.json` manifest file that defines its metadata and components, and its features are typically namespaced to avoid command conflicts. You can discover and install pre-built plugins from official or community marketplaces using the `/plugin` command, or create your own by packaging local `.claude/` configurations into a versioned directory structure.
|
||||
Claude Code plugins are shareable packages that bundle multiple customizations, including slash commands, specialized agents, skills, hooks, and Model Context Protocol (MCP) servers, into a single installable unit. They serve as a standardized way to distribute complex AI workflows across different projects or within an engineering team, ensuring that every developer has access to the same tools and coding standards.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Plugins
|
||||
|
||||
Claude Code plugins are shareable packages that bundle multiple customizations—including slash commands, specialized agents, skills, hooks, and Model Context Protocol (MCP) servers—into a single installable unit. They serve as a standardized way to distribute complex AI workflows across different projects or within an engineering team, ensuring that every developer has access to the same tools and coding standards. Each plugin is organized around a `plugin.json` manifest file that defines its metadata and components, and its features are typically namespaced to avoid command conflicts. You can discover and install pre-built plugins from official or community marketplaces using the `/plugin` command, or create your own by packaging local `.claude/` configurations into a versioned directory structure.
|
||||
Claude Code plugins are shareable packages that bundle multiple customizations, including slash commands, specialized agents, skills, hooks, and Model Context Protocol (MCP) servers, into a single installable unit. They serve as a standardized way to distribute complex AI workflows across different projects or within an engineering team, ensuring that every developer has access to the same tools and coding standards.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
# Prompt Caching
|
||||
|
||||
Prompt caching in Claude Code is a performance-optimizing feature that stores the frequently used "prefixes" of your conversations—such as your entire codebase state, system instructions, and tool definitions—so they don't have to be reprocessed from scratch with every new message. In an agentic environment where Claude often re-reads your files multiple times to maintain context, caching acts as a "checkpoint" system: while the initial write to the cache carries a slight premium, every subsequent interaction that reuses that prefix receives a 90% discount on input tokens and up to an 85% reduction in latency. Claude Code handles this automatically by placing "cache breakpoints" at strategic points in the prompt (like after your [CLAUDE.md](http://CLAUDE.md) and project structure), ensuring that even as your conversation grows, the "static" foundation of your project remains instantly accessible and cost-effective.
|
||||
Claude prompt caching is a feature that stores frequently used, long-context information (system prompts, large documents, codebase, examples) to speed up response times and significantly reduce API costs. It enables up to 90% cheaper and 85% faster processing by avoiding re-computation of consistent prompt prefixes, often using XML tags for structuring data
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
- [@official@Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)
|
||||
- [@official@Prompt caching configuration]](https://code.claude.com/docs/en/model-config#prompt-caching-configuration)
|
||||
- [@article@Unlocking Efficiency: A Practical Guide to Claude Prompt Caching](https://medium.com/@mcraddock/unlocking-efficiency-a-practical-guide-to-claude-prompt-caching-3185805c0eef)
|
||||
- [@official@Prompt caching configuration](https://code.claude.com/docs/en/model-config#prompt-caching-configuration)
|
||||
- [@article@Unlocking Efficiency: A Practical Guide to Claude Prompt Caching](https://medium.com/@mcraddock/unlocking-efficiency-a-practical-guide-to-claude-prompt-caching-3185805c0eef)
|
||||
@@ -1,6 +1,6 @@
|
||||
# Rewind Conversations
|
||||
|
||||
To rewind a conversation in Claude Code, you can use the `/rewind` slash command or the `Esc + Esc` keyboard shortcut to open the interactive checkpoint menu. This feature leverages the tool's automatic snapshotting, which creates a restore point for every user prompt and file modification throughout your session. Once the menu is open, you can scroll through your previous inputs and select a specific point to restore code and conversation, which reverts both your files and the chat history; restore conversation only, which keeps your current code changes but wipes later chat turns; or summarize from here, which distills all subsequent interactions into a compact summary to reclaim context window space. Because rewinding can fork your conversation into parallel timelines, it is most effective for "undoing" AI mistakes or exploring alternative implementation paths without manually reverting file edits.
|
||||
To rewind a conversation in Claude Code, you can use the `/rewind` slash command or the `Esc + Esc` keyboard shortcut to open the interactive checkpoint menu. This feature leverages the tool's automatic snapshotting, which creates a restore point for every user prompt and file modification throughout your session.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Security Best Practices
|
||||
|
||||
Security is the most critical pillar of using Claude Code because giving an AI agent the ability to execute terminal commands and modify files creates a powerful "intern with root access" who is susceptible to prompt injection and data exfiltration. Since Claude can unknowingly ingest malicious instructions from untrusted files, READMEs, or even web content—potentially leading to accidental database resets or the leaking of `.env` secrets—you must implement a zero-trust defense-in-depth strategy. This involves layering OS-level sandboxing to isolate the AI's filesystem reach, enforcing strict permission tiers (Deny for sensitive keys, Ask for destructive commands like rm or git push, and Allow only for read-only tools), and using audit logs to monitor for unusual behavior.
|
||||
Security is the most critical pillar of using Claude Code because giving an AI agent the ability to execute terminal commands and modify files creates a powerful "intern with root access" who is susceptible to prompt injection and data exfiltration.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,8 +1,7 @@
|
||||
# Setting up Claude Code
|
||||
|
||||
To set up Claude Code, you first install the CLI tool through your terminal using a single command tailored to your operating system. For macOS, Linux, or WSL, you run `curl -fsSL https://claude.ai/install.sh | bash`, while Windows users can use PowerShell to run `irm https://claude.ai/install.ps1 | iex`. Once the installation is complete, you navigate to any code project directory and type `claude`, which will trigger a one-time login process where you authenticate using your [Claude.ai](http://Claude.ai) account or an Anthropic Console API key. After logging in, the tool is ready to use immediately; it will automatically index your project files and await your natural language instructions to start coding, debugging, or running terminal commands.
|
||||
To set up Claude Code, you first install the CLI tool through your terminal using a single command tailored to your operating system. For macOS, Linux, or WSL, you run `curl -fsSL https://claude.ai/install.sh | bash`, while Windows users can use PowerShell to run `irm https://claude.ai/install.ps1 | iex`. Once the installation is complete, you navigate to any code project directory and type `claude`, which will trigger a one-time login process where you authenticate using your Claude account or an Anthropic Console API key. After logging in, the tool is ready to use immediately.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
- [@official@Getting started with Claude Code](https://code.claude.com/docs/en/quickstart)
|
||||
- [@article@Claude Code: A Guide With Practical Examples](https://www.datacamp.com/tutorial/claude-code)
|
||||
- [@official@Getting started with Claude Code](https://code.claude.com/docs/en/quickstart)
|
||||
@@ -1,6 +1,6 @@
|
||||
# Skill Best Practices
|
||||
|
||||
When configuring Claude Code skills, the primary best practice is to optimize for discoverability and context efficiency by using precise YAML frontmatter and "lazy loading." Your skill's `description` should act as a clear semantic trigger, using specific keywords that help Claude identify exactly when to activate the expert instructions without bloating the context window of every conversation. Structure the `SKILL.md` with a narrow, modular focus rather than creating a "Swiss Army Knife" skill; if a workflow has non-negotiable side effects, use `disable-model-invocation: true` to ensure it only runs when manually triggered via a slash command. Additionally, leverage argument placeholders (like `$ARGUMENTS`) to make your skills reusable across different files, and store them in the project’s `.claude/skills/` directory so they are version-controlled and shared with your team. Finally, keep skill instructions deterministic by providing step-by-step tool sequences, which ensure Claude follows your project’s "golden path" for complex tasks like deployments or security audits.
|
||||
When configuring Claude Code skills, the primary best practice is to optimize for discoverability and context efficiency by using precise YAML frontmatter and "lazy loading." Your skill's `description` should act as a clear semantic trigger, using specific keywords that help Claude identify exactly when to activate the expert instructions without bloating the context window of every conversation. Structure the `SKILL.md` with a narrow, modular focus rather than creating a "Swiss Army Knife" skill.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
@@ -8,4 +8,4 @@ Visit the following resources to learn more:
|
||||
- [@official@Skill authoring best practices](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices)
|
||||
- [@official@The Complete Guide to Building Skills for Claude](https://resources.anthropic.com/hubfs/The-Complete-Guide-to-Building-Skill-for-Claude.pdf?hsLang=en)
|
||||
- [@article@A useful cheatsheet for understanding Claude Skills](https://www.reddit.com/r/ClaudeAI/comments/1qbpe91/a_useful_cheatsheet_for_understanding_claude/)
|
||||
- [@article@Writing Claude Skills That Actually Work: A Guide to What Works (And What Doesn’t)](https://medium.com/@creativeaininja/writing-claude-skills-that-actually-work-a-guide-to-what-works-and-what-doesnt-2dfcd9593106)
|
||||
- [@article@Writing Claude Skills That Actually Work: A Guide to What Works (And What Doesn’t)](https://medium.com/@creativeaininja/writing-claude-skills-that-actually-work-a-guide-to-what-works-and-what-doesnt-2dfcd9593106)
|
||||
@@ -1,6 +1,6 @@
|
||||
# Skills for MCP
|
||||
|
||||
Skills act as structured, reusable knowledge packages that dramatically improve how Claude interacts with MCP (Model Context Protocol) servers by giving it precise, context-aware instructions for specific tools and workflows. Rather than relying on Claude to infer how to use a given MCP server from scratch each time, skills provide curated guidance — best practices, common patterns, error handling strategies, and domain-specific context — that help Claude make smarter, more reliable decisions when invoking tools, chaining calls, and interpreting results.
|
||||
Skills act as structured, reusable knowledge packages that dramatically improve how Claude interacts with MCP (Model Context Protocol) servers by giving it precise, context-aware instructions for specific tools and workflows. Rather than relying on Claude to infer how to use a given MCP server from scratch each time, skills provide curated guidance that helps Claude make smarter, more reliable decisions when invoking tools, chaining calls, and interpreting results.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,14 +1,13 @@
|
||||
# Skills
|
||||
|
||||
In Claude Code, Skills are self-contained folders of "expert knowledge" and repeatable workflows that Claude loads dynamically into its context only when the task requires it. Each skill is anchored by a `SKILL.md` file containing YAML frontmatter—which helps Claude identify the skill's purpose without bloating the context window—and a body of specific instructions, often accompanied by supporting scripts, assets, or reference documents. While `CLAUDE.md` provides permanent project context, skills are designed for progressive disclosure, acting as on-demand "expert modes" for specialized actions like auditing security, formatting complex documentation, or orchestrating multi-step deployment pipelines. You can trigger them manually using a slash command (e.g., `/deploy`) or let Claude autonomously invoke them when it detects a match with a skill's description, ensuring the AI maintains high precision and follows "non-negotiable" procedures without the overhead of keeping every rule in its immediate memory at once.
|
||||
In Claude Code, Skills are self-contained folders of "expert knowledge" and repeatable workflows that Claude loads dynamically into its context only when the task requires it. Each skill is anchored by a `SKILL.md` file containing YAML frontmatter, which helps Claude identify the skill's purpose without bloating the context window, and a body of specific instructions
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
- [@course@Agent Skills with Anthropic](https://www.deeplearning.ai/short-courses/agent-skills-with-anthropic/)
|
||||
- [@course@Introduction to agent skills](https://anthropic.skilljar.com/introduction-to-agent-skills)
|
||||
- [@official@Extend Claude with skills](https://code.claude.com/docs/en/skills#extend-claude-with-skills)
|
||||
- [@official@The Complete Guide to Building Skills for Claude](https://resources.anthropic.com/hubfs/The-Complete-Guide-to-Building-Skill-for-Claude.pdf?hsLang=en)
|
||||
- [@opensource@skill](https://github.com/anthropics/skills)
|
||||
- [@article@Claude Code Skills — Equipping Your Claude Code Agents with more Superpowers](https://medium.com/@ooi_yee_fei/claude-code-skills-superpowering-claude-code-agents-a42b44a58ae2)
|
||||
- [@video@Claude Code Skills & skills.sh - Crash Course](https://www.youtube.com/watch?v=rcRS8-7OgBo)
|
||||
- [@video@Stop Using Claude Code Without Skills](https://www.youtube.com/watch?v=vIUJ4Hd7be0)
|
||||
- [@video@Claude Code Skills are INSANE (and you’re not using them correctly)](https://www.youtube.com/watch?v=thxXGxYIwUI)
|
||||
- [@video@Claude Code Skills & skills.sh - Crash Course](https://www.youtube.com/watch?v=rcRS8-7OgBo)
|
||||
@@ -1,6 +1,6 @@
|
||||
# Skills
|
||||
|
||||
Claude Code skills are modular packages of instructions, scripts, and assets that teach the AI assistant how to perform specific, repeatable workflows. Each skill is stored in a dedicated folder containing a mandatory [SKILL.md](http://SKILL.md) file, which uses YAML frontmatter to define its name and a description that the AI uses to automatically discover and load the skill when relevant. By bundling domain-specific knowledge—such as corporate brand guidelines, database schemas, or complex deployment sequences—skills prevent "context bloat" because the full instructions only load into the conversation when the task at hand requires them. They can be invoked manually using slash commands like /review or /deploy, and they often include executable bash scripts or templates that ensure the AI follows a disciplined, verified process rather than guessing how to complete a task.
|
||||
Claude Code skills are modular packages of instructions, scripts, and assets that teach the AI assistant how to perform specific, repeatable workflows. Each skill is stored in a dedicated folder containing a mandatory SKILL.md file, which uses YAML frontmatter to define its name and a description that the AI uses to automatically discover and load the skill when relevant.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Sonnet
|
||||
|
||||
Claude Sonnet is a high-performance large language model that strikes an ideal balance between advanced reasoning intelligence and rapid processing speed. It serves as the versatile "workhorse" of the Claude family, capable of handling complex programming tasks, such as multi-file refactoring and autonomous debugging, while operating significantly faster and more cost-effectively than the top-tier Opus model. With a large token context window and sophisticated vision capabilities, it excels at interpreting technical documentation, analyzing dense data charts, and translating legacy codebases into modern frameworks. Because it offers near-frontier intelligence with the efficiency required for real-time applications, it is the default choice for most professional development workflows and agentic tasks that require consistent, high-quality results without the latency of larger models.
|
||||
Claude Sonnet is a high-performance large language model that strikes an ideal balance between advanced reasoning intelligence and rapid processing speed. It serves as the versatile "workhorse" of the Claude family, capable of handling complex programming tasks, such as multi-file refactoring and autonomous debugging, while operating significantly faster and more cost-effectively than the top-tier Opus model.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Subagents
|
||||
|
||||
Subagents are specialized AI assistants that function as independent "team members" to handle focused tasks on behalf of the main agent. Each subagent operates within its own isolated context window, meaning it starts with a clean slate and does not clutter your primary conversation with large amounts of intermediate research or technical logs. They are typically defined by a markdown file in the .claude/agents/ directory, where you specify their unique system prompt, expertise, and restricted tool access—for example, a "researcher" might have access to web search and file reading but be barred from editing code. You can manage them using the /agents command to create, edit, or manually invoke a specialist like a "debugger" or "reviewer," though the main agent can also automatically delegate tasks to them if their description matches a complex sub-goal.
|
||||
Subagents are specialized AI assistants that function as independent "team members" to handle focused tasks on behalf of the main agent. Each subagent operates within its own isolated context window, meaning it starts with a clean slate and does not clutter your primary conversation with large amounts of intermediate research or technical logs.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Subagents
|
||||
|
||||
Subagents are specialized AI assistants that function as independent "team members" to handle focused tasks on behalf of the main agent. Each subagent operates within its own isolated context window, meaning it starts with a clean slate and does not clutter your primary conversation with large amounts of intermediate research or technical logs. They are typically defined by a markdown file in the `.claude/agents/` directory, where you specify their unique system prompt, expertise, and restricted tool access—for example, a "researcher" might have access to web search and file reading but be barred from editing code. You can manage them using the `/agents` command to create, edit, or manually invoke a specialist like a "debugger" or "reviewer," though the main agent can also automatically delegate tasks to them if their description matches a complex sub-goal.
|
||||
Subagents are specialized AI assistants that function as independent "team members" to handle focused tasks on behalf of the main agent. Each subagent operates within its own isolated context window, meaning it starts with a clean slate and does not clutter your primary conversation with large amounts of intermediate research or technical logs. They are typically defined by a markdown file in the `.claude/agents/` directory, where you specify their unique system prompt, expertise, and restricted tool access.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Thinking modes & Effort
|
||||
|
||||
Using thinking modes and adjusting effort levels in Claude Code is essential for balancing deep reasoning with operational efficiency. By defaulting to Plan Mode for complex tasks, you force Claude to perform "reconnaissance before the raid," allowing it to research your architecture and draft a structured strategy before touching any source code. This approach significantly reduces "vibe-coding" errors and hallucinations, as the model can analyze dependencies without the risk of accidental modifications. Furthermore, you can fine-tune Claude's cognitive energy using the effort parameter (available through the /model command); higher effort levels trigger "extended thinking" or "ultrathink," which use more test-time compute to solve multifaceted logic or debugging puzzles, while lower effort levels optimize for speed and cost on simpler tasks. This "measure twice, cut once" philosophy ensures that Claude remains a precise architectural partner rather than just a code generator, ultimately saving you time and money by getting complex implementations right on the first attempt.
|
||||
Using thinking modes and adjusting effort levels in Claude Code is essential for balancing deep reasoning with operational efficiency. Furthermore, you can fine-tune Claude's cognitive energy using the effort parameter (available through the /model command).
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Tools
|
||||
|
||||
Tools in Claude Code are specialized functions that allow the AI assistant to perform actions on your computer rather than just generating text. These functions are categorized into client-side tools that interact with your local environment—such as `Bash` for running terminal commands, `Read` and `Edit` for file manipulation, and `Glob` or `Grep` for searching codebases—and server-side tools like `WebSearch` for fetching real-time information from the internet. When you give Claude a task, it uses these tools in an "agentic loop" to gather context, propose changes, and verify results, often requiring your permission before executing high-impact actions.
|
||||
Tools are specialized functions that allow the AI assistant to perform actions on your computer rather than just generating text. These functions are categorized into client-side tools that interact with your local environment, such as `Bash` for running terminal commands, `Read` and `Edit` for file manipulation, and `Glob` or `Grep` for searching codebases, and server-side tools like `WebSearch` for fetching real-time information from the internet.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Understand Claude Pricing
|
||||
|
||||
Claude Code offers a flexible, dual-path pricing model designed to accommodate both individual power users and high-scale enterprise teams. You can access the tool through a fixed-rate subscription (such as the Pro or Max plans), which provides a generous recurring allocation of messages shared across the web interface and the terminal, making costs predictable for daily development. Alternatively, you can use a pay-as-you-go API model, where you are billed based on the total number of "tokens" (small units of text) processed in each interaction. In this model, costs are split into input charges for the code and instructions you send, and output charges for the code Claude generates.
|
||||
Claude Code offers a flexible, dual-path pricing model designed to accommodate both individual power users and high-scale enterprise teams. You can access the tool through a fixed-rate subscription (such as the Pro or Max plans), which provides a generous recurring allocation of messages shared across the web interface and the terminal, making costs predictable for daily development. Alternatively, you can use a pay-as-you-go API model, where you are billed based on the total number of "tokens" (small units of text) processed in each interaction.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,8 +1,3 @@
|
||||
# Use /compact and /clear
|
||||
|
||||
Regularly using `/compact` and `/clear` is the most effective way to prevent "context rot" and manage spiraling API costs while working with Claude Code. Because Claude re-processes your entire conversation history with every new message, a session that has accumulated thousands of lines of terminal output and file diffs will eventually become expensive, slow, and prone to "forgetting" early instructions. Using `/compact` allows you to summarize long research or debugging threads into a lean set of key findings, effectively "zipping" the conversation so you can continue without losing essential progress. In contrast, `/clear` is vital when switching to an unrelated task; it wipes the current history to provide a clean slate.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
- [@article@Claude Code Compaction](https://stevekinney.com/courses/ai-development/claude-code-compaction)
|
||||
- [@article@Claude Code Best Practices: Memory Management](https://medium.com/@codecentrevibe/claude-code-best-practices-memory-management-7bc291a87215)
|
||||
Regularly using `/compact` and `/clear` is the most effective way to prevent "context rot" and manage spiraling API costs while working with Claude Code. Using `/compact` allows you to summarize long research or debugging threads into a lean set of key findings, effectively "zipping" the conversation so you can continue without losing essential progress. In contrast, `/clear` is vital when switching to an unrelated task; it wipes the current history to provide a clean slate.
|
||||
@@ -1,6 +1,6 @@
|
||||
# Use subagents and hooks
|
||||
|
||||
In Claude Code, Subagents and Hooks are powerful architectural tools that manage the context window by practicing "selective attention," ensuring the main conversation stays lean while specialized tasks remain high-precision. Subagents act as isolated "expert bubbles" that run in their own independent context windows with restricted toolsets; they can ingest thousands of tokens of raw logs or documentation, returning only a concise final summary to your main session. This prevents your primary conversation from becoming "bloated" with noisy intermediate data, which maintains Claude's reasoning quality and reduces per-turn costs. Hooks, on the other hand, provide a deterministic way to inject or prune context at key lifecycle moments.
|
||||
Subagents and Hooks are powerful architectural tools that manage the context window by practicing "selective attention," ensuring the main conversation stays lean while specialized tasks remain high-precision. Subagents act as isolated "expert bubbles" that run in their own independent context windows with restricted toolsets, while Hooks provide a deterministic way to inject or prune context at key lifecycle moments.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Using Claude Code
|
||||
|
||||
Claude Code is a sophisticated agentic tool that provides significant power through its ability to execute commands and edit files, but it requires a disciplined approach to prevent security risks and runaway costs. Because every interaction—including the files Claude reads, the commands it runs, and the long "thought" processes of models like Opus—consumes tokens, a single unguided session can quickly become expensive. You should be familiar with the inner workings of Claude Code and follow best practices to maximize efficiency.
|
||||
Claude Code is a sophisticated agentic tool that provides significant power through its ability to execute commands and edit files, but it requires a disciplined approach to prevent security risks and runaway costs.
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
|
||||
@@ -8,4 +8,5 @@ Claude Code can be accessed through three main interfaces: a Command Line Interf
|
||||
|
||||
Visit the following resources to learn more:
|
||||
|
||||
- [@official@Use Claude Code everywhere](https://code.claude.com/docs/en/overview#use-claude-code-everywhere)
|
||||
- [@official@Use Claude Code everywhere](https://code.claude.com/docs/en/overview#use-claude-code-everywhere)
|
||||
- [@course@Claude 101](https://anthropic.skilljar.com/claude-101)
|
||||
Reference in New Issue
Block a user