CFG7 verified templates

7 Best Claude Code Settings & Configuration Templates — Customize Your Setup

Claude Code settings are JSON-based configuration files that define how Claude Code operates within your development environment. Stored at .claude/settings.json for project-level configuration or ~/.claude/settings.json for global defaults, these files control everything from tool permissions and model selection to MCP server connections, hook automations, and security policies. Settings are the foundation of a customized, secure, and team-consistent Claude Code deployment.

The settings architecture in Claude Code follows a layered precedence model. At the base layer, Anthropic provides sensible defaults that work for most individual developers. The global settings file at ~/.claude/settings.json sits on top of those defaults and applies personal preferences across every project on your machine. Project-level settings at .claude/settings.json override global values for that specific repository, enabling teams to enforce consistent configurations through version control. Finally, .claude/settings.local.json provides machine-specific overrides that stay out of version control for sensitive values like local paths or API tokens.

Permissions management is the most critical aspect of Claude Code settings. The allowedTools array defines which tools Claude can use without asking for approval. Common entries include Read, Write, Bash, Glob, and Grep. You can use glob-style patterns to restrict scope, for example allowing Write(src/**) to permit file writes only within the source directory while blocking writes to configuration files at the project root. The denyTools array provides an explicit blocklist that takes precedence over all allow rules, giving security teams a hard stop for dangerous operations.

Model selection through settings allows teams to standardize which AI model Claude Code uses. While Claude Code defaults to the latest available model, enterprise teams often pin to a specific model version for consistency and cost predictability. The model key in settings accepts any supported Anthropic model identifier, and project-level overrides let performance-critical repositories use more capable models while routine projects use cost-efficient alternatives.

MCP server configuration is where settings become particularly powerful. The mcpServersobject defines connections to Model Context Protocol servers that extend Claude Code's capabilities with external tools and data sources. Each server entry specifies a command to launch the server, optional arguments, and environment variables. Teams use MCP servers to connect Claude Code to databases, internal APIs, documentation systems, project management tools, and custom toolchains. Project-level MCP configurations ensure that every developer on a team has access to the same extended capabilities without manual setup.

Hook configuration within settings defines automated scripts that run at specific points during Claude Code operations. The hooks object maps event names like PreToolUse and PostToolUse to arrays of hook definitions. Each hook specifies a matcher pattern to filter which tools trigger it and a command to execute. Hooks configured in settings are more reliable than ad-hoc scripts because they load automatically when Claude Code starts and apply consistently across all sessions. Security-conscious teams use settings-based hooks to enforce code scanning, secret detection, and compliance logging on every tool invocation.

Telemetry and privacy settings give developers control over what data Claude Code collects and transmits. The settings file can disable telemetry entirely, restrict data collection to specific categories, or configure custom endpoints for enterprise logging systems. These controls are essential for teams working under data governance regulations like GDPR, HIPAA, or SOC 2, where understanding and limiting data flow is a compliance requirement rather than a preference.

This directory contains 7 curated settings templates covering the most common configuration patterns. Each template has been validated for correctness, documented with inline comments explaining every key, and categorized by use case. Whether you need a security-hardened configuration for enterprise deployment, a streamlined setup for solo development, or a team-shared template that balances productivity with guardrails, you will find production-ready solutions below.

Top 5 Settings Collections Compared

TemplateFocus AreaPermissionsMCP ServersBest For
Enterprise LockdownSecurity & ComplianceRestrictive with denyToolsAudit logging onlyRegulated industries
Full-Stack DeveloperProductivityBroad with directory scopingDatabase, API, docsIndividual developers
Team Shared BaselineCollaborationModerate with local overridesShared team toolsTeams of 5-50
Minimal StarterSimplicityDefault with basic scopingNoneNew Claude Code users
CI/CD PipelineAutomationHeadless with no promptsBuild and deploy toolsAutomated workflows

How to Configure Claude Code Settings

Create a .claude/settings.json file in your project root (or ~/.claude/settings.json for global defaults). Below is an annotated example showing the most commonly used configuration keys:

{
  // Permissions: which tools Claude can use without asking
  "allowedTools": [
    "Read",
    "Glob",
    "Grep",
    "Write(src/**)",
    "Bash(npm test)",
    "Bash(npm run lint)"
  ],

  // Explicit blocklist (overrides allowedTools)
  "denyTools": [
    "Bash(rm -rf *)",
    "Bash(git push --force)"
  ],

  // Model selection
  "model": "claude-sonnet-4-20250514",

  // MCP server connections
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://localhost:5432/mydb"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "./docs"]
    }
  },

  // Hook automations
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write",
        "command": "node .claude/hooks/scan-secrets.js"
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Bash",
        "command": "node .claude/hooks/log-commands.js"
      }
    ]
  },

  // Telemetry preferences
  "telemetry": {
    "enabled": false
  }
}

Step 1: Create the .claude directory in your project root with mkdir -p .claude.

Step 2: Create settings.json inside that directory with the keys relevant to your workflow. Start minimal and expand as needed.

Step 3: For machine-specific values (API keys, local paths), create settings.local.json in the same directory and add it to .gitignore.

Step 4: Commit .claude/settings.json to version control so your team inherits the configuration automatically.

All Settings & Configuration Templates

7 resources

Claude Code System Prompts (110+ Strings)

Advanced

Up-to-date collection of all Claude Code system prompts (110+ strings) extracted from the latest npm version. Includes tool descriptions, agent prompts, utility functions, and a changelog tracking 141+ versions.

system-promptsreferenceinternals
8,300by Piebald-AI
GitHub

Claude Code Showcase

Intermediate

Comprehensive Claude Code project configuration example with hooks, skills, agents, commands, and GitHub Actions workflows. Demonstrates reusable domain knowledge and automated quality gates with MCP server integrations.

showcaseconfigurationgithub-actions
5,700by ChrisWiles
GitHub

Claude Code Setup Template

Beginner

Shared starter template configuration and CLAUDE.md memory bank system for Claude Code. Provides configuration files, hooks, and slash commands to help set up projects with persistent context across sessions.

templatememory-bankconfiguration
2,200by centminmod
GitHub

Trail of Bits Claude Code Config

Advanced

Opinionated defaults, documentation, and workflows for Claude Code from security firm Trail of Bits. Covers sandboxing, permissions, hooks, skills, MCP servers, and usage patterns developed through security audits.

securityconfigurationsandboxing
1,800by trailofbits
GitHub

Claude Code Settings & Agents

Intermediate

Curated collection of Claude Code settings, skills, and sub-agents for enhanced development workflows. Includes pre-configured setups for multiple LLM providers (Anthropic, DeepSeek, Azure), reusable skills, and specialized subagents.

settingsconfigurationmulti-provider
1,400by feiskyer
GitHub

Claude Code Framework Configs

Beginner

Production-ready Claude Code configurations for popular frameworks including Next.js 15, shadcn/ui, Tailwind CSS, Drizzle ORM, and Vercel AI SDK. Features a CLI tool for intelligent framework config merging.

nextjstailwindvercel
624by Matt-Dionis
GitHub

CC Settings CLI Tool

Beginner

CLI tool for applying standardized configuration templates to .claude/settings.json with intelligent merging. Supports built-in templates (casual, strict, node), local files, and GitHub URLs with dry-run previews.

cli-toolsettingstemplates
320by dyoshikawa
GitHub

Frequently Asked Questions

What are Claude Code settings?

Claude Code settings are JSON configuration files that control how Claude Code behaves in your development environment. They define permissions for tool usage, specify which AI model to use, configure MCP (Model Context Protocol) server connections, set up hook automations, manage telemetry preferences, and establish security boundaries. Settings allow you to tailor Claude Code to your project requirements, team policies, and security posture without modifying any source code. The primary settings file is settings.json, which can exist at both project and global levels.

Where are Claude Code settings stored?

Claude Code settings are stored in two primary locations. Project-level settings live at .claude/settings.json in your project root directory and apply only to that specific project. Global settings live at ~/.claude/settings.json in your home directory and apply as defaults across all projects. When both exist, project-level settings take precedence over global settings for overlapping keys. Additionally, enterprise teams can distribute settings through .claude/settings.local.json for machine-specific overrides that should not be committed to version control.

What's the difference between project and global settings?

Project settings (.claude/settings.json) are scoped to a single repository and are typically committed to version control so all team members share the same configuration. They define project-specific permissions, hooks, and MCP server connections relevant to that codebase. Global settings (~/.claude/settings.json) apply across every project on your machine and are ideal for personal preferences like model selection, telemetry opt-out, editor integration, and default permission levels. When a key appears in both files, the project-level value wins, giving teams the ability to enforce standards while allowing individual customization for non-critical preferences.

How do I configure permissions and security?

Permissions in Claude Code settings control which tools Claude is allowed to use and what actions it can take without explicit approval. The allowedTools array specifies permitted tools like file reading, writing, and shell execution. You can use glob patterns to restrict file access to specific directories or file types. The denyTools array explicitly blocks dangerous operations. Security-focused teams typically start with a restrictive baseline in global settings and selectively expand permissions at the project level. You can also configure approval requirements so that certain high-risk actions like running shell commands or modifying configuration files always require manual confirmation before execution.

Can I share settings across teams?

Yes, Claude Code settings are designed for team sharing. The recommended approach is to commit .claude/settings.json to your repository so every team member automatically inherits the same permissions, hooks, and MCP server configurations when they clone the project. For sensitive or machine-specific values like API keys or local paths, use .claude/settings.local.json which should be added to .gitignore. Enterprise teams often maintain a shared settings template repository that gets pulled into new projects through onboarding scripts or project scaffolding tools. This ensures consistent security policies, approved tool lists, and hook configurations across the entire organization.

Know a settings template we're missing?

Help us build the most complete directory of Claude Code configuration templates.

Submit a Resource