Claude Code Capabilities

How subagents run

Custom subagents

A subagent is a Markdown file with YAML frontmatter, and its body is the system prompt. If several definitions share a name, the higher location wins: managed settings, then the --agents CLI flag, then .claude/agents/ (project), then ~/.claude/agents/ (user), then plugins. For subagents, the project copy beats the user copy, which is the opposite of skills.

---
name: code-reviewer
description: Expert code review specialist. Use immediately after writing or modifying code.
tools: Read, Grep, Glob, Bash
model: inherit
---

You are a senior code reviewer ensuring high standards of code quality and security.

Save it as .claude/agents/code-reviewer.md, or pass a JSON definition for one session with claude --agents '{...}'. Keep descriptions short: past 15,000 tokens of combined custom descriptions, Claude Code shows a startup warning.

Quality-gate hooks: TeammateIdle, TaskCreated and TaskCompleted. Exit code 2 keeps a teammate working, or blocks creating or completing the task.

• Start one by typing ultracode in a prompt or asking Claude to "use a workflow". /effort ultracode lets Claude plan workflows for every substantive task. /workflows shows runs, and s saves a run's script.
• Saved workflows live in .claude/workflows/ or ~/.claude/workflows/ and run as /<name>. /deep-research is bundled.
• Script API: agent(), pipeline(), parallel(), phase(), log() and args. Intermediate results stay in script variables, so Claude's context holds only the final answer.
• Limits: 16 concurrent agents by default, 1,000 agents per run, no user input mid-run, no direct filesystem access from the script. Disable with "disableWorkflows": true.

export const meta = { name: 'audit-routes', description: 'Audit every route handler for missing auth checks' }

const found = await agent('List every .ts file under src/routes/.', {
  schema: { type: 'object', required: ['files'], properties: { files: { type: 'array', items: { type: 'string' } } } },
})
const audits = await pipeline(found.files, file =>
  agent(`Audit ${file} for missing authentication checks.`, { label: file }))
return audits.filter(Boolean)

Inside the body: $ARGUMENTS, $0, $1 and so on for arguments, and !`command` to inject shell output. Keep SKILL.md under 500 lines and move detail into supporting files.

---
description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed or wants a commit message.
---

## Current changes
!`git diff HEAD`

## Instructions
Summarize the changes above in two or three bullet points, then list any risks.

Bundled skills and key built-in commands

# In a session
/plugin marketplace add your-org/plugins#v1.2.0
/plugin install commit-commands@claude-plugins-official

# From your shell
claude plugin install formatter@your-org --scope project
claude --plugin-dir ./my-plugin      # load a local plugin for one session

# Remote MCP server (GitHub's hosted server, authenticated with a personal access token)
claude mcp add --transport http github https://api.githubcopilot.com/mcp/ \
  --header "Authorization: Bearer ${GITHUB_PAT}"

MCP scopes, .mcp.json and how to pass server credentials safely are covered in the File Structure & Configuration guide.

Block edits to protected files (PreToolUse with exit 2). .claude/hooks/protect-files.sh:

#!/bin/bash
FILE_PATH=$(jq -r '.tool_input.file_path // empty')
for pattern in ".env" "package-lock.json" ".git/"; do
  if [[ "$FILE_PATH" == *"$pattern"* ]]; then
    echo "Blocked: $FILE_PATH matches protected pattern '$pattern'" >&2
    exit 2
  fi
done
exit 0

{
  "hooks": {
    "PreToolUse": [
      { "matcher": "Edit|Write",
        "hooks": [ { "type": "command", "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/protect-files.sh" } ] }
    ]
  }
}

Switching: Shift+Tab cycles modes in the CLI. Use --permission-mode <mode> at launch or permissions.defaultMode in settings. auto and bypassPermissions don't take effect from project or local settings, so set them in ~/.claude/settings.json. Admins can turn modes off with permissions.disableAutoMode and permissions.disableBypassPermissionsMode.

Permission rules

• Order: deny, then ask, then allow. The first match decides, and specificity doesn't change the order. A bare tool name in deny removes the tool from Claude's context.
• Compound commands are split on &&, ||, ;, | and newlines, and every part must be allowed.
• Bash rules are not a security boundary: Bash(rm *) doesn't stop /bin/rm or bash -c. Use the sandbox or a PreToolUse hook for real enforcement.
• Writes to protected paths such as .git, .claude, .vscode, .mcp.json and shell rc files are never auto-approved outside bypassPermissions. Manual and acceptEdits prompt, auto sends them to the classifier, and dontAsk denies them.

{
  "permissions": {
    "allow": ["Bash(npm run *)", "Bash(git commit *)"],
    "deny":  ["Bash(git push *)", "Read(./.env)", "Read(./secrets/**)"]
  }
}

{
  "sandbox": {
    "enabled": true,
    "filesystem": { "allowWrite": ["~/.kube", "/tmp/build"] },
    "network": { "allowedDomains": ["github.com", "*.npmjs.org"] }
  }
}

• Switch with /model, --model or the model setting. Admins restrict choices with availableModels. Current models run a 1M-token window natively, so the [1m] suffix matters only for Opus 4.6 and Sonnet 4.6.
• Effort is low, medium, high, xhigh or max, set with /effort. The 5.5 models default to medium.
• Subagent cost: set model: haiku in a simple subagent's frontmatter, or CLAUDE_CODE_SUBAGENT_MODEL as the default for subagents that don't set their own (add CLAUDE_CODE_SUBAGENT_MODEL_FORCE=1 to force it on all).
• Context: auto-compaction runs near the window limit. Use /context to see what fills it, /compact Focus on ... to summarize with intent, and /clear between unrelated tasks, which costs nothing.
• Cost reference: the docs report an enterprise average of about $13 per developer per active day ($150 to $250 per month). /usage shows session cost.

claude --bare -p "Extract the main function names from auth.py" \
  --allowedTools "Read" --max-turns 3 \
  --output-format json \
  --json-schema '{"type":"object","properties":{"functions":{"type":"array","items":{"type":"string"}}},"required":["functions"]}' \
  | jq '.structured_output'

GitHub Actions and GitLab

• /install-github-app installs the Claude GitHub App, stores ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN as a repo secret, pushes a branch with the workflow file, and opens a ready-to-create pull request in your browser. It works only with github.com repositories and needs admin access.
• anthropics/claude-code-action@v1 answers @claude mentions when there is no prompt input, and runs in automation mode on any event (including schedule) when prompt is set. Pass CLI flags through claude_args.
• GitLab CI/CD support is in beta and maintained by GitLab. A job runs claude -p with ANTHROPIC_API_KEY as a masked variable.

name: Claude Code
on:
  issue_comment: { types: [created] }
  pull_request_review_comment: { types: [created] }
jobs:
  claude:
    if: contains(github.event.comment.body, '@claude')
    runs-on: ubuntu-latest
    permissions: { contents: write, pull-requests: write, issues: write, id-token: write, actions: read }
    steps:
      - uses: actions/checkout@v6
        with: { fetch-depth: 1 }
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          claude_args: "--max-turns 5"

Scheduling and parallel work