Claude Code — community skills Orchestration Guide

Delegate coding tasks to Claude Code (Anthropic's autonomous coding agent CLI) via the community skills terminal. Claude Code v2.x can read files, write code, run shell commands, spawn subagents, and manage git workflows autonomously.

Prerequisites

• Install: npm install -g @anthropic-ai/claude-code
• Auth: run claude once to log in (browser OAuth for Pro/Max, or set ANTHROPIC_API_KEY)
• Console auth: claude auth login --console for API key billing
• SSO auth: claude auth login --sso for Enterprise
• Check status: claude auth status (JSON) or claude auth status --text (human-readable)
• Health check: claude doctor — checks auto-updater and installation health
• Version check: claude --version (requires v2.x+)
• Update: claude update or claude upgrade

Two Orchestration Modes

community skills interacts with Claude Code in two fundamentally different ways. Choose based on the task.

Mode 1: Print Mode (-p) — Non-Interactive (PREFERRED for most tasks)

Print mode runs a one-shot task, returns the result, and exits. No PTY needed. No interactive prompts. This is the cleanest integration path.

terminal(command="claude -p 'Add error handling to all API calls in src/' --allowedTools 'Read,Edit' --max-turns 10", workdir="/path/to/project", timeout=120)

When to use print mode:

• One-shot coding tasks (fix a bug, add a feature, refactor)
• CI/CD automation and scripting
• Structured data extraction with --json-schema
• Piped input processing (cat file | claude -p "analyze this")
• Any task where you don't need multi-turn conversation

Print mode skips ALL interactive dialogs — no workspace trust prompt, no permission confirmations. This makes it ideal for automation.

Mode 2: Interactive PTY via tmux — Multi-Turn Sessions

Interactive mode gives you a full conversational REPL where you can send follow-up prompts, use slash commands, and watch Claude work in real time. Requires tmux orchestration.

# Start a tmux session
terminal(command="tmux new-session -d -s claude-work -x 140 -y 40")

# Launch Claude Code inside it
terminal(command="tmux send-keys -t claude-work 'cd /path/to/project && claude' Enter")

# Wait for startup, then send your task
# (after ~3-5 seconds for the welcome screen)
terminal(command="sleep 5 && tmux send-keys -t claude-work 'Refactor the auth module to use JWT tokens' Enter")

# Monitor progress by capturing the pane
terminal(command="sleep 15 && tmux capture-pane -t claude-work -p -S -50")

# Send follow-up tasks
terminal(command="tmux send-keys -t claude-work 'Now add unit tests for the new JWT code' Enter")

# Exit when done
terminal(command="tmux send-keys -t claude-work '/exit' Enter")

When to use interactive mode:

• Multi-turn iterative work (refactor → review → fix → test cycle)
• Tasks requiring human-in-the-loop decisions
• Exploratory coding sessions
• When you need to use Claude's slash commands (/compact, /review, /model)

PTY Dialog Handling (CRITICAL for Interactive Mode)

Claude Code presents up to two confirmation dialogs on first launch. You MUST handle these via tmux send-keys:

Dialog 1: Workspace Trust (first visit to a directory)

❯ 1. Yes, I trust this folder    ← DEFAULT (just press Enter)
  2. No, exit

Handling: tmux send-keys -t <session> Enter — default selection is correct.

Dialog 2: Bypass Permissions Warning (only with --dangerously-skip-permissions)

❯ 1. No, exit                    ← DEFAULT (WRONG choice!)
  2. Yes, I accept

Handling: Must navigate DOWN first, then Enter:

tmux send-keys -t <session> Down && sleep 0.3 && tmux send-keys -t <session> Enter

Robust Dialog Handling Pattern

# Launch with permissions bypass
terminal(command="tmux send-keys -t claude-work 'claude --dangerously-skip-permissions \"your task\"' Enter")

# Handle trust dialog (Enter for default "Yes")
terminal(command="sleep 4 && tmux send-keys -t claude-work Enter")

# Handle permissions dialog (Down then Enter for "Yes, I accept")
terminal(command="sleep 3 && tmux send-keys -t claude-work Down && sleep 0.3 && tmux send-keys -t claude-work Enter")

# Now wait for Claude to work
terminal(command="sleep 15 && tmux capture-pane -t claude-work -p -S -60")

Note: After the first trust acceptance for a directory, the trust dialog won't appear again. Only the permissions dialog recurs each time you use --dangerously-skip-permissions.

CLI Subcommands

Subcommand	Purpose
claude	Start interactive REPL
claude "query"	Start REPL with initial prompt
claude -p "query"	Print mode (non-interactive, exits when done)
cat file | claude -p "query"	Pipe content as stdin context
claude -c	Continue the most recent conversation in this directory
claude -r "id"	Resume a specific session by ID or name
claude auth login	Sign in (add --console for API billing, --sso for Enterprise)
claude auth status	Check login status (returns JSON; --text for human-readable)
claude mcp add <name> -- <cmd>	Add an MCP server
claude mcp list	List configured MCP servers
claude mcp remove <name>	Remove an MCP server
claude agents	List configured agents
claude doctor	Run health checks on installation and auto-updater
claude update / claude upgrade	Update Claude Code to latest version
claude remote-control	Start server to control Claude from claude.ai or mobile app
claude install [target]	Install native build (stable, latest, or specific version)
claude setup-token	Set up long-lived auth token (requires subscription)
claude plugin / claude plugins	Manage Claude Code plugins
claude auto-mode	Inspect auto mode classifier configuration

Print Mode Deep Dive

Structured JSON Output

terminal(command="claude -p 'Analyze auth.py for security issues' --output-format json --max-turns 5", workdir="/project", timeout=120)

Returns a JSON object with:

{
  "type": "result",
  "subtype": "success",
  "result": "The analysis text...",
  "session_id": "75e2167f-...",
  "num_turns": 3,
  "total_cost_usd": 0.0787,
  "duration_ms": 10276,
  "stop_reason": "end_turn",
  "terminal_reason": "completed",
  "usage": { "input_tokens": 5, "output_tokens": 603, ... },
  "modelUsage": { "claude-sonnet-4-6": { "costUSD": 0.078, "contextWindow": 200000 } }
}

Key fields: session_id for resumption, num_turns for agentic loop count, total_cost_usd for spend tracking, subtype for success/error detection (success, error_max_turns, error_budget).

Streaming JSON Output

For real-time token streaming, use stream-json with --verbose:

terminal(command="claude -p 'Write a summary' --output-format stream-json --verbose --include-partial-messages", timeout=60)

Returns newline-delimited JSON events. Filter with jq for live text:

claude -p "Explain X" --output-format stream-json --verbose --include-partial-messages | \
  jq -rj 'select(.type == "stream_event" and .event.delta.type? == "text_delta") | .event.delta.text'

Stream events include system/api_retry with attempt, max_retries, and error fields (e.g., rate_limit, billing_error).

Bidirectional Streaming

For real-time input AND output streaming:

claude -p "task" --input-format stream-json --output-format stream-json --replay-user-messages

--replay-user-messages re-emits user messages on stdout for acknowledgment.

Piped Input

# Pipe a file for analysis
terminal(command="cat src/auth.py | claude -p 'Review this code for bugs' --max-turns 1", timeout=60)

# Pipe multiple files
terminal(command="cat src/*.py | claude -p 'Find all TODO comments' --max-turns 1", timeout=60)

# Pipe command output
terminal(command="git diff HEAD~3 | claude -p 'Summarize these changes' --max-turns 1", timeout=60)

JSON Schema for Structured Extraction

terminal(command="claude -p 'List all functions in src/' --output-format json --json-schema '{\"type\":\"object\",\"properties\":{\"functions\":{\"type\":\"array\",\"items\":{\"type\":\"string\"}}},\"required\":[\"functions\"]}' --max-turns 5", workdir="/project", timeout=90)

Parse structured_output from the JSON result. Claude validates output against the schema before returning.

Session Continuation

# Start a task
terminal(command="claude -p 'Start refactoring the database layer' --output-format json --max-turns 10 > /tmp/session.json", workdir="/project", timeout=180)

# Resume with session ID
terminal(command="claude -p 'Continue and add connection pooling' --resume $(cat /tmp/session.json | python3 -c 'import json,sys; print(json.load(sys.stdin)[\"session_id\"])') --max-turns 5", workdir="/project", timeout=120)

# Or resume the most recent session in the same directory
terminal(command="claude -p 'What did you do last time?' --continue --max-turns 1", workdir="/project", timeout=30)

# Fork a session (new ID, keeps history)
terminal(command="claude -p 'Try a different approach' --resume <id> --fork-session --max-turns 10", workdir="/project", timeout=120)

Bare Mode for CI/Scripting

terminal(command="claude --bare -p 'Run all tests and report failures' --allowedTools 'Read,Bash' --max-turns 10", workdir="/project", timeout=180)

--bare skips hooks, plugins, MCP discovery, and CLAUDE.md loading. Fastest startup. Requires ANTHROPIC_API_KEY (skips OAuth).

To selectively load context in bare mode:

To load	Flag
System prompt additions	--append-system-prompt "text" or --append-system-prompt-file path
Settings	--settings <file-or-json>
MCP servers	--mcp-config <file-or-json>
Custom agents	--agents '<json>'

Fallback Model for Overload

terminal(command="claude -p 'task' --fallback-model haiku --max-turns 5", timeout=90)

Automatically falls back to the specified model when the default is overloaded (print mode only).

Complete CLI Flags Reference

Session & Environment

Flag	Effect
-p, --print	Non-interactive one-shot mode (exits when done)
-c, --continue	Resume most recent conversation in current directory
-r, --resume <id>	Resume specific session by ID or name (interactive picker if no ID)
--fork-session	When resuming, create new session ID instead of reusing original
--session-id <uuid>	Use a specific UUID for the conversation
--no-session-persistence	Don't save session to disk (print mode only)
--add-dir <paths...>	Grant Claude access to additional working directories
-w, --worktree [name]	Run in an isolated git worktree at .claude/worktrees/<name>
--tmux	Create a tmux session for the worktree (requires --worktree)
--ide	Auto-connect to a valid IDE on startup
--chrome / --no-chrome	Enable/disable Chrome browser integration for web testing
--from-pr [number]	Resume session linked to a specific GitHub PR
--file <specs...>	File resources to download at startup (format: file_id:relative_path)

Model & Performance

| Flag | Effect | | -------------------------- | --------------------------------------------------------------------------------- | ---- | | --model <alias> | Model selection: sonnet, opus, haiku, or full name like claude-sonnet-4-6 | | --effort <level> | Reasoning depth: low, medium, high, max, auto | Both | | --max-turns <n> | Limit agentic loops (print mode only; prevents runaway) | | --max-budget-usd <n> | Cap API spend in dollars (print mode only) | | --fallback-model <model> | Auto-fallback when default model is overloaded (print mode only) | | --betas <betas...> | Beta headers to include in API requests (API key users only) |

Permission & Safety

Flag	Effect
--dangerously-skip-permissions	Auto-approve ALL tool use (file writes, bash, network, etc.)
--allow-dangerously-skip-permissions	Enable bypass as an option without enabling it by default
--permission-mode <mode>	default, acceptEdits, plan, auto, dontAsk, bypassPermissions
--allowedTools <tools...>	Whitelist specific tools (comma or space-separated)
--disallowedTools <tools...>	Blacklist specific tools
--tools <tools...>	Override built-in tool set ("" = none, "default" = all, or tool names)

Output & Input Format

Flag	Effect
--output-format <fmt>	text (default), json (single result object), stream-json (newline-delimited)
--input-format <fmt>	text (default) or stream-json (real-time streaming input)
--json-schema <schema>	Force structured JSON output matching a schema
--verbose	Full turn-by-turn output
--include-partial-messages	Include partial message chunks as they arrive (stream-json + print)
--replay-user-messages	Re-emit user messages on stdout (stream-json bidirectional)

System Prompt & Context

Flag	Effect
--append-system-prompt <text>	Add to the default system prompt (preserves built-in capabilities)
--append-system-prompt-file <path>	Add file contents to the default system prompt
--system-prompt <text>	Replace the entire system prompt (use --append instead usually)
--system-prompt-file <path>	Replace the system prompt with file contents
--bare	Skip hooks, plugins, MCP discovery, CLAUDE.md, OAuth (fastest startup)
--agents '<json>'	Define custom subagents dynamically as JSON
--mcp-config <path>	Load MCP servers from JSON file (repeatable)
--strict-mcp-config	Only use MCP servers from --mcp-config, ignoring all other MCP configs
--settings <file-or-json>	Load additional settings from a JSON file or inline JSON
--setting-sources <sources>	Comma-separated sources to load: user, project, local
--plugin-dir <paths...>	Load plugins from directories for this session only
--disable-slash-commands	Disable all skills/slash commands

Debugging

Flag	Effect
-d, --debug [filter]	Enable debug logging with optional category filter (e.g., "api,hooks", "!1p,!file")
--debug-file <path>	Write debug logs to file (implicitly enables debug mode)

Agent Teams

Flag	Effect
--teammate-mode <mode>	How agent teams display: auto, in-process, or tmux
--brief	Enable SendUserMessage tool for agent-to-user communication

Tool Name Syntax for --allowedTools / --disallowedTools

Read                    # All file reading
Edit                    # File editing (existing files)
Write                   # File creation (new files)
Bash                    # All shell commands
Bash(git *)             # Only git commands
Bash(git commit *)      # Only git commit commands
Bash(npm run lint:*)    # Pattern matching with wildcards
WebSearch               # Web search capability
WebFetch                # Web page fetching
mcp__<server>__<tool>   # Specific MCP tool

Settings & Configuration

Settings Hierarchy (highest to lowest priority)

1. CLI flags — override everything
2. Local project: .claude/settings.local.json (personal, gitignored)
3. Project: .claude/settings.json (shared, git-tracked)
4. User: ~/.claude/settings.json (global)

Permissions in Settings

{
  "permissions": {
    "allow": ["Bash(npm run lint:*)", "WebSearch", "Read"],
    "ask": ["Write(*.ts)", "Bash(git push*)"],
    "deny": ["Read(.env)", "Bash(rm -rf *)"]
  }
}

Memory Files (CLAUDE.md) Hierarchy

1. Global: ~/.claude/CLAUDE.md — applies to all projects
2. Project: ./CLAUDE.md — project-specific context (git-tracked)
3. Local: .claude/CLAUDE.local.md — personal project overrides (gitignored)

Use the # prefix in interactive mode to quickly add to memory: # Always use 2-space indentation.

Interactive Session: Slash Commands

Session & Context

Command	Purpose
/help	Show all commands (including custom and MCP commands)
/compact [focus]	Compress context to save tokens; CLAUDE.md survives compaction. E.g., /compact focus on auth logic
/clear	Wipe conversation history for a fresh start
/context	Visualize context usage as a colored grid with optimization tips
/cost	View token usage with per-model and cache-hit breakdowns
/resume	Switch to or resume a different session
/rewind	Revert to a previous checkpoint in conversation or code
/btw <question>	Ask a side question without adding to context cost
/status	Show version, connectivity, and session info
/todos	List tracked action items from the conversation
/exit or Ctrl+D	End session

Development & Review

Command	Purpose
/review	Request code review of current changes
/security-review	Perform security analysis of current changes
/plan [description]	Enter Plan mode with auto-start for task planning
/loop [interval]	Schedule recurring tasks within the session
/batch	Auto-create worktrees for large parallel changes (5-30 worktrees)

Configuration & Tools

Command	Purpose
/model [model]	Switch models mid-session (use arrow keys to adjust effort)
/effort [level]	Set reasoning effort: low, medium, high, max, or auto
/init	Create a CLAUDE.md file for project memory
/memory	Open CLAUDE.md for editing
/config	Open interactive settings configuration
/permissions	View/update tool permissions
/agents	Manage specialized subagents
/mcp	Interactive UI to manage MCP servers
/add-dir	Add additional working directories (useful for monorepos)
/usage	Show plan limits and rate limit status
/voice	Enable push-to-talk voice mode (20 languages; hold Space to record, release to send)
/release-notes	Interactive picker for version release notes

Custom Slash Commands

Create .claude/commands/<name>.md (project-shared) or ~/.claude/commands/<name>.md (personal):

# .claude/commands/deploy.md

Run the deploy pipeline:

1. Run all tests
2. Build the Docker image
3. Push to registry
4. Update the $ARGUMENTS environment (default: staging)

Usage: /deploy production — $ARGUMENTS is replaced with the user's input.

Skills (Natural Language Invocation)