Claude Code Security: Permissions, Review and CI

Introduction

AI-assisted development moves fast. That speed is the whole point. But speed without security is a liability. Every line of code Claude Code generates, every dependency it installs, every API route it creates: all of it lives in your production environment. And your production environment faces real threats from real attackers.

This is Part 4 of the Claude Code Mastery Series, and it is entirely focused on security. We cover Anthropic's Claude Code security review capabilities, practical scanning workflows, CI/CD integration for automated checks, enterprise deployment patterns, and the permission model that lets you control exactly what Claude Code can and cannot do.

AI-assisted changes need the same threat model and review as other code. Tell the reviewer what data the application handles and where authorization is enforced. Generated code can contain plausible mistakes, so inspect the implementation and test the relevant boundary.

What You Will Learn

• Claude Code Security: Anthropic's vulnerability scanning announcement
• How to use Claude Code for security audits and vulnerability detection
• CI/CD integration with GitHub Actions for automated security checks
• Enterprise deployment patterns for teams and organizations
• Security best practices specific to AI-generated code
• The Claude Code permission model: allowlists, denylists, and hook-based security gates

Info: Anthropic announced Claude Code security review capabilities on February 20, 2026. Since then, automated security reviews have rolled out more broadly and are now available to Claude Code users on paid Claude plans and supported Console accounts.

Claude Code Security

On February 20, 2026, Anthropic announced Claude Code's security review capabilities for finding real, exploitable vulnerabilities in codebases. This was not a minor feature update. It represented a significant expansion of what AI can do for defensive security.

What Claude Code Security Does

During its testing phase, Claude Code Security analyzed production open-source codebases and discovered more than 500 previously unknown vulnerabilities. These were not trivial style issues or theoretical concerns. They were exploitable vulnerabilities, the kind that lead to data breaches, unauthorized access, and service compromise.

The system uses the same Claude reasoning stack that powers Claude Code for development, but applies it specifically to security analysis. It reads code with the mindset of an attacker, traces data flows through complex applications, and identifies vulnerability patterns that static analysis tools routinely miss.

Current Availability

Claude Code security reviews are now broadly available to:

• Individual paid users on Claude Pro or Max
• Teams and enterprises using Claude Code across shared workflows
• Developers using supported Console accounts with pay-as-you-go billing

Anthropic continues to refine the workflows, but the core security review capabilities are no longer limited to a narrow preview cohort.

Why This Matters

Traditional static analysis tools like Snyk, SonarQube, and CodeQL operate on pattern matching. They are good at finding known vulnerability signatures: SQL injection through string concatenation, missing CSRF tokens, hardcoded credentials. But they struggle with logic bugs, complex data flow vulnerabilities, and novel attack patterns.

Claude Code Security reasons about code the way a human security researcher would. It understands business logic. It can trace a user input from an HTTP request through middleware, across service boundaries, into a database query, and identify where sanitization is missing along the way. That kind of deep analysis used to require expensive manual penetration testing.

What It Finds

The types of vulnerabilities Claude Code Security identifies include:

• SQL injection — Including parameterized query bypasses and ORM misuse
• Cross-site scripting (XSS) — Stored, reflected, and DOM-based variants
• Authentication bypasses — Logic flaws in login flows, session management, and token validation
• Authorization failures — Broken access control where users can access resources they should not
• Server-side request forgery (SSRF) — Internal network access through manipulated URLs
• Insecure deserialization — Exploitable object reconstruction from untrusted data
• Path traversal — File system access outside intended directories
• Race conditions — Time-of-check to time-of-use vulnerabilities in concurrent code

Security Scanning Workflows

Even if you are not using the full automated review workflow in CI, you can use Claude Code itself for security auditing. The underlying Claude models have strong security reasoning capabilities. You just need to prompt them correctly.

Running a Security Audit

Start a Claude Code session in your project and give it a focused security mandate:

claude "Perform a security audit of this codebase. Focus on: (1) authentication and authorization logic, (2) input validation and sanitization, (3) SQL injection vectors including ORM misuse, (4) XSS vulnerabilities in rendered content, (5) CSRF protection, (6) sensitive data exposure in logs or error messages, (7) insecure direct object references, (8) hardcoded secrets or credentials. For each finding, rate severity as Critical, High, Medium, or Low. Provide the exact file, line, and a specific remediation."

Claude Code will systematically walk through your codebase, reading files, tracing data flows, and reporting its findings. A typical audit on a medium-sized application takes ten to fifteen minutes and produces a structured report.

Targeted Scanning

For larger codebases, focus the scan on high-risk areas:

claude "Audit the authentication system in src/lib/auth/ and src/app/api/auth/. Check for: JWT token validation issues, session fixation, password reset flow vulnerabilities, brute force protection, and secure cookie configuration. Show me the exact code that is vulnerable and the fix."

Dependency Auditing

Third-party dependencies are a common attack vector:

claude "Review our package.json dependencies for known security issues. Run npm audit and analyze the results. For each vulnerability found, explain the risk, whether it affects us based on how we use the package, and the recommended fix — whether that is updating, replacing, or adding a workaround."

API Security Review

APIs are the most exposed attack surface for most applications:

claude "Review all API routes in src/app/api/. For each route, check: Is authentication required and enforced? Is input validated with Zod or similar? Are responses sanitized to prevent data leakage? Is rate limiting applied? Are error responses safe (no stack traces, no internal details)? List every route and its security status."

Tip: Run security audits regularly, not just before deployment. In our experience at Luminous Digital Visions, and as covered in our hooks and MCP configuration guide, the best practice is to run a focused security scan after each significant feature is completed. Finding an SQL injection during development costs ten minutes to fix. Finding it in production costs days of incident response.

CI/CD Integration

Automated security checks in your CI/CD pipeline catch vulnerabilities before they reach production. Claude Code can be integrated into GitHub Actions workflows to review code on every pull request.

GitHub Actions Workflow for Claude Code Review

Here is a workflow that runs Claude Code on every pull request to check for security issues:

name: Claude Code Security Review
on:
  pull_request:
    branches: [main]

permissions:
  contents: read
  pull-requests: write

jobs:
  security-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install Claude Code
        run: |
          curl -fsSL https://claude.ai/install.sh | bash
          echo "$HOME/.local/bin" >> $GITHUB_PATH

      - name: Get changed files
        id: changed
        run: |
          FILES=$(git diff --name-only origin/main...HEAD -- '*.ts' '*.tsx' '*.js' '*.jsx')
          echo "files=$FILES" >> $GITHUB_OUTPUT

      - name: Run security review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude -p "Review the following changed files for security vulnerabilities. Focus on authentication, input validation, SQL injection, XSS, and sensitive data exposure. Output a structured report in Markdown format. Changed files: ${{ steps.changed.outputs.files }}" > review.md

      - name: Post review comment
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review.md', 'utf8');
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: `## Security Review\n\n${review}`
            });

Automated PR Quality Checks

Beyond security, you can use Claude Code in CI for general code quality:

      - name: Run quality check
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude -p "Review the git diff for this PR. Check for: type safety issues, missing error handling, performance concerns, and test coverage gaps. Be specific about file names and line numbers." > quality.md

Pre-Merge Security Gates

For critical repositories, make the security check a required status check. If Claude Code identifies any Critical or High severity issues, fail the workflow:

      - name: Check for critical issues
        run: |
          if grep -qi "severity: critical\|severity: high" review.md; then
            echo "Critical or high severity issues found. Blocking merge."
            exit 1
          fi

Warning: CI/CD integration with Claude Code uses your Anthropic API key. Store it as a GitHub secret, never in the workflow file. Limit the key's permissions and monitor usage to prevent unexpected costs. Consider using a dedicated API key for CI that is separate from developer keys.

Set enterprise controls at the correct layer

Start with the organization’s approved identity, repository and data-access model. Decide which projects may use the tool, which services it can reach and what audit records are required. Keep production secrets out of general development sessions.

Use the current managed settings and permission documentation for enforceable controls. Project instructions describe a workflow; they do not establish an isolation boundary by themselves.

Review MCP servers, plugins and hooks as executable dependencies. Separate development and production credentials. Use organization-owned settings where the policy needs to apply across a team, and verify the effective settings on a test machine.

Log the information needed for incident investigation without collecting entire prompts, secrets or customer records by default. Define access and retention for logs before enabling broad collection.

Security Best Practices for AI-Generated Code

AI-generated code is not inherently less secure than human-written code. In many cases, it follows security best practices more consistently because the model has been trained on enormous volumes of secure code patterns. But there are specific risks to be aware of.

Always Review Authentication Logic

Authentication is the highest-risk area. Claude Code will generate JWT verification, password hashing, session management, and OAuth flows correctly in most cases. But "most cases" is not good enough for authentication. Review every line. Specifically check:

• Password hashing uses bcrypt, scrypt, or Argon2 (not MD5 or SHA-256 alone)
• JWT tokens are verified with the correct algorithm and secret
• Session tokens are regenerated after login to prevent fixation
• Password reset tokens expire and are single-use
• Rate limiting is applied to login endpoints

Validate All Inputs

Claude Code usually adds input validation when asked. But it might validate at the wrong layer, or miss an edge case. Check that:

• Validation happens at the API boundary, not deep inside business logic
• String lengths are bounded to prevent memory exhaustion
• Numeric inputs have reasonable min/max bounds
• File uploads are checked for type, size, and content (not just extension)
• Array inputs have length limits to prevent denial-of-service

Check for Sensitive Data Exposure

AI-generated error handlers sometimes leak too much information:

claude "Review all error handlers in the API routes. Ensure that no error response includes stack traces, database query details, internal file paths, or configuration values. In production mode, errors should return only a status code, error type, and a user-friendly message."

Dependency Management

When Claude Code installs packages, verify them:

• Check the package name for typosquatting (e.g., lodash vs l0dash)
• Verify the package has a meaningful number of downloads and recent maintenance
• Run npm audit after installation
• Pin dependency versions in production to prevent supply chain attacks

Environment Variable Hygiene

Never let Claude Code hardcode secrets. If you see a secret in generated code, fix it immediately. Use a PreToolUse hook to catch this automatically:

#!/bin/bash
# block-hardcoded-secrets.sh
INPUT=$(cat)
CONTENT=$(echo "$INPUT" | jq -r '.tool_input.new_string // .tool_input.content // empty')

if echo "$CONTENT" | grep -qEi '(api[_-]?key|secret|password|token)\s*[:=]\s*["\x27][A-Za-z0-9+/=]{20,}'; then
  echo "BLOCKED: Possible hardcoded secret detected in file content" >&2
  exit 2
fi

exit 0

Claude Code Permission Model

Claude Code includes a permission system that controls which tools it can use. This is your first line of defense against unintended actions.

Tool Allowlists and Denylists

In your settings.json, you can explicitly allow or deny specific tools:

{
  "allowedTools": [
    "Read",
    "Write",
    "Edit",
    "Glob",
    "Grep",
    "Bash(npm test)",
    "Bash(npm run build)",
    "Bash(npx prisma *)"
  ]
}

This configuration lets Claude Code read and write files, search the codebase, and run specific commands, but nothing else. It cannot run arbitrary bash commands, which prevents accidental rm -rf situations.

Hook-Based Security Gates

Hooks provide granular control that goes beyond simple allow/deny lists. You can write hooks that inspect the specific content of a tool invocation:

• Block writes to specific directories (e.g., prisma/migrations/)
• Prevent modifications to configuration files without explicit approval
• Require tests to pass before allowing new file creation
• Log all database-related commands for audit purposes

Audit Logging

For enterprise environments, thorough audit logging is essential. A PostToolUse hook can log every action Claude Code takes:

#!/bin/bash
# audit-log.sh
INPUT=$(cat)
TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
USER=$(whoami)
TOOL=$(echo "$INPUT" | jq -r '.tool_name')
PROJECT=$(basename "$(pwd)")

echo "{\"timestamp\":\"$TIMESTAMP\",\"user\":\"$USER\",\"project\":\"$PROJECT\",\"tool\":\"$TOOL\",\"input\":$(echo "$INPUT" | jq -c '.tool_input')}" >> /var/log/claude-code/audit.jsonl

exit 0

This creates a structured audit trail that compliance teams can query and review.

Layered Security Model

As we covered in our full-stack development guide, production readiness requires multiple checks. The most robust setup combines multiple layers:

1. CLAUDE.md rules — Tell Claude Code what it should not do (soft constraint)
2. Tool allowlists — Restrict which tools are available (hard constraint)
3. PreToolUse hooks — Inspect and block specific tool invocations (programmable constraint)
4. PostToolUse hooks — Audit and validate after execution (monitoring layer)
5. CI/CD checks — Catch anything that slips through during development (final gate)

Warning: No single layer is sufficient on its own. CLAUDE.md can be ignored under certain prompting conditions. Tool allowlists are coarse-grained. Hooks can crash. CI/CD only catches issues after code is written. Use all five layers together for defense in depth.

Build a security review record

Record the change, reviewers, checks performed and unresolved findings. An assistant’s analysis can identify issues for investigation; it is not a compliance certification or a complete security audit.

For sensitive changes, use independent review and tests that exercise the trust boundary. Confirm authorization on the server, validate inputs, test error handling and inspect what appears in logs. Maintain a rollback path for the release.

Frequently Asked Questions

Continue the Series

Security is not a checkbox you mark once. It is a continuous practice that evolves with your codebase, your team, and the threat environment. The tools and patterns in this article give you a strong foundation, but they work best when applied consistently and reviewed regularly.

What We Covered

• Claude Code Security — Anthropic's dedicated vulnerability scanning tool, announced February 20, 2026
• Security scanning workflows — Practical prompts for auditing authentication, APIs, dependencies, and data handling
• CI/CD integration — GitHub Actions workflows for automated security reviews on every pull request
• Enterprise patterns — Shared configurations, API key management, onboarding, and compliance
• Security best practices — Specific guidance for reviewing AI-generated code
• Permission model — Allowlists, denylists, hooks, and layered security architecture

Up Next: Part 5

The final installment of the Claude Code Mastery Series covers the most advanced features: Agent Teams for coordinated multi-agent development, git worktrees for parallel development, background tasks, and real-world workflows that combine everything in the series. This is where it all comes together.

Continue to Part 5: Agent Teams and Parallel Development

Need Expert Help?

Security auditing and enterprise Claude Code deployment are areas where professional guidance pays for itself quickly. A misconfigured security setup costs far more to fix after an incident than to set up correctly from the start. Luminous Digital Visions provides security consulting and enterprise AI integration services.

Get a Free Consultation

For implementation, explore Luminous services or discuss your project.