Claude Code Enterprise Mastery: Ship Faster, Ship Safer

How Claude Code inherits the developer's shell permissions and why that matters. The four permission modes: Normal, Auto-accept, Plan, and Bypass. When to use each mode in practice. Permission rules: Allow, Ask, and Deny with live examples. Tool-level permissions for Bash, Read, Write, Edit, WebFetch, and Skill. Pattern matching syntax for granular control. Live demo: configuring permissions on the TeamPulse project.

The five layers of configuration in priority order: enterprise managed policies, command-line flags, local project settings, shared project settings, and global user settings. Deep dive into managed-settings.json for enforcing organization-wide policy that developers cannot override. Live demo: setting up a layered configuration for a real team.

Sandbox mode for filesystem and network isolation. How sandboxing reduces permission prompts by 84% while maintaining security. Network request approval and WebFetch permissions. Command blocklist: curl, wget blocked by default. MCP server allowlists for controlling external integrations. Live demo: enabling sandbox on the TeamPulse project.

Prompt injection through code comments, README files, and package READMEs. Credential exposure via .env files, SSH keys, and API tokens. Supply chain risks from malicious npm/pip packages. Subagent context inheritance and permission propagation. The deny-everything-then-allow approach. Practical deny rules every enterprise should have. Security review prompt walkthrough.

CLAUDE.md is not documentation — it is persistent AI context. How Claude Code loads and references CLAUDE.md automatically. How Anthropic's own engineering teams use CLAUDE.md for documenting mistakes, style conventions, and PR templates. The CLAUDE.md hierarchy: system-level, user-level, project-level, and nested directories. Token budget awareness: keeping it concise at around 2,500 tokens.

Live build: creating a CLAUDE.md from scratch for the TeamPulse codebase. Essential sections: project architecture, coding standards, testing requirements, PR format, common mistakes, and deployment rules. Nested CLAUDE.md for monorepo setups with per-package context. The /init command for auto-generating an initial CLAUDE.md. What NOT to put in CLAUDE.md: secrets, credentials, and overly verbose documentation.

Committing .claude/settings.json and CLAUDE.md to version control. PR reviews that update CLAUDE.md to capture learnings from every review. CLAUDE.md governance: who owns it, how often to update, and review cadence. Sharing CLAUDE.md across git worktrees. Live demo: team onboarding flow with CLAUDE.md.

Skills as SKILL.md files with YAML frontmatter and markdown instructions. Skill scopes: project-level, personal, and plugin-distributed. Auto-invocation based on description matching. Skill priority: enterprise, personal, then project level. Permission control for allowing and denying specific skills. Live demo: creating a code-review skill and a deploy skill.

Plugins as bundled collections of skills, agents, hooks, and commands. The plugin marketplace and how to discover, install, and audit plugins. Enterprise concerns: plugins include executable code and must be reviewed. Notable production-ready plugins. Private plugin marketplaces for enterprise with admin-curated catalogs. Security review process before team-wide deployment.

Hooks as event-driven automation: PreToolUse, PostToolUse, Stop, SubagentStart, SubagentStop. Shell hooks vs. HTTP hooks. Use cases: auto-run tests after code changes, lint before commits, desktop notifications, and blocking dangerous commands. Hook timeout configuration. Enterprise use: PreToolUse hooks as security gates. Live demo: setting up a test-on-save hook.

What subagents are: separate context windows for focused tasks. Built-in subagent types: Explore for codebase scanning, Task for execution, Plan for design. Why subagents matter: keeping main context clean and preventing context drift. Spawning subagents via slash commands, skills, or Claude's own decision. Live demo: subagent exploration and feature implementation on TeamPulse.

Running multiple Claude Code sessions simultaneously. Why branches alone are not enough — sessions stepping on each other's files. The native --worktree (-w) flag: one command creates isolated checkout, branch, and Claude session. Practical setup: 3-5 parallel sessions. Live demo: two worktree sessions building frontend and backend features in parallel with git log proof of independent commits.

Background tasks for long-running processes. The /loop command for recurring prompts on interval. Task management with the /tasks dialog. Headless mode with claude -p for scripted automation in CI/CD. Bypass mode in Docker containers for fully autonomous CI runs.

What Remote Control does: bridges a local terminal session to any device. Setup with /rc generating a QR code. Security model: code never leaves your machine, encrypted bridge, no inbound ports. Use cases: monitoring long builds, approving agent actions from mobile. Live demo: controlling a Claude session from a second device.

Using claude -p (headless mode) in scripts: structured input, structured output. Output formatting with --output-format json for pipeline consumption. Extracting results with jq. Session metadata: cost tracking, duration, session ID for multi-step analysis. Model selection for CI: Sonnet for cost efficiency. Live demo: automated security review and codebase scanning from the command line.

Full PR workflow: creating a branch, fixing a vulnerability with Claude, generating a commit message following CLAUDE.md standards, and producing a PR description. Claude-assisted commit messages that follow team conventions automatically. Live demo: fixing the SQL injection vulnerability and pushing a clean PR.

Adding Claude security review to GitHub Actions. The anthropics/claude-code-action as the official GitHub Action. Configuring review to run only on pull requests, after tests pass, using Sonnet for cost efficiency. Setting up ANTHROPIC_API_KEY as a repository secret. Live demo: pushing the workflow, creating a PR, and watching the automated security review run and post comments.

How context size drives cost: every turn re-sends the full context. The /cost command for dollar-level tracking on API and Enterprise plans. The /context command for token-level breakdown by category. Live demo: watching context grow during a heavy analysis task and seeing the cost impact in real time.

The /compact command: summarizing conversation history to free context. The /clear command: full reset when switching tasks. Effort levels: low for simple tasks, medium as default, high (Ultrathink) for complex architecture decisions. Model selection: Opus 4.6 for deep reasoning, Sonnet 4.6 for daily work, Haiku 4.5 for CI automation. The enterprise strategy: default to Sonnet plus medium effort, saving 40-60% on spend.

Setting per-user and org-wide spending caps in the admin dashboard. Extra usage at API rates: when and how to enable. Monitoring strategies: admin dashboard vs. log parsing vs. AI gateway approach. Cost allocation by team and project. Practical budget templates for teams of 10, 50, and 100 engineers.

Core guarantee: Anthropic does not train on enterprise or API data. Zero-Data-Retention (ZDR) mode on Enterprise plans. Transcript retention and configurable cleanup periods. Data flow: terminal to Anthropic API to response, or via Bedrock/Vertex for VPC isolation. Consumer vs. enterprise data policies. What to tell your legal and security team. Live demo: exploring local session transcripts and audit data.

Enterprise audit logs: user sign-ins, model calls, file operations. SOC 2 Type II alignment. Log retention and export options. Integration with Splunk, Datadog, and Elastic for SIEM. The Compliance API for real-time automated monitoring. Building audit trails for regulated industries.

Healthcare (HIPAA): when ZDR is mandatory and PHI handling. Financial services: data residency and model audit trails. Government: VPC-only deployment with no data leaving controlled networks. GDPR: data processing agreements and right to erasure. General best practices: principle of least privilege, regular permission audits, security review cadence.

Starting with a fresh, unconfigured clone of TeamPulse. Verifying zero configuration: no .claude directory, no CLAUDE.md. Building the enterprise stack step by step: deny rules, CLAUDE.md hierarchy, custom skills, PostToolUse hooks, and sandbox mode.

Implementing a new weekly digest feature using the full governance stack. Subagents exploring the codebase and implementing across services. PostToolUse hooks running tests automatically after every file edit. CLAUDE.md guiding coding standards. Commit messages following team format. Everything governed simultaneously.

Running the custom code-review skill against staged changes. Context review with /context showing total session usage. Final configuration summary: permissions, hooks, CLAUDE.md files, skills, and git log. The complete enterprise stack built in under 30 minutes.

Phase 1: Pilot team of 5-10 engineers to establish baselines. Phase 2: Standards definition with CLAUDE.md templates, permission policies, and skill libraries. Phase 3: Rollout with onboarding process, training sessions, and support channels. Measuring success: cycle time, PR throughput, developer satisfaction. Common pitfalls: no governance, no CLAUDE.md, inconsistent permissions, no cost monitoring.

Cowork: Claude Code's agentic capabilities for non-engineering teams. Claude in Chrome, Excel, and PowerPoint — the broader enterprise surface. The plugin marketplace and building internal plugins. Model improvements and their impact on existing workflows. Course recap, call to action, and next steps with AI Guru.