Build a Claude Code settings.json, CLAUDE.md and .mcp.json. Pick your model, permission mode, allow/deny rules and MCP servers, then copy. Free, no signup.
Claude Code is configured by three separate files that do three unrelated jobs, and most of the time lost setting it up comes from mixing them up. This generator produces all three from one form, live, in your browser: a settings.json that controls the model and the permission system, a CLAUDE.md that gives the agent your project's commands and conventions, and a .mcp.json that connects external MCP servers. Pick your options on the left, and the tab you are looking at on the right updates on every keystroke. Nothing is uploaded — the whole generator is a client-side React component, so your project name, test command and deny rules never leave the tab.
| File | Path the tool writes | What it controls |
|---|---|---|
settings.json | .claude/settings.json | Default model, permission mode, allow/deny rules, transcript retention, telemetry env vars |
CLAUDE.md | ./CLAUDE.md | Project context loaded into every session — stack, commands, conventions, guardrails |
.mcp.json | ./.mcp.json | MCP servers, in a file you can commit so the whole team gets the same tools |
The generator labels the settings file .claude/settings.json — the project-scoped location, which is the one you commit so teammates inherit the same rules. The identical JSON is valid at ~/.claude/settings.json if you want the settings to follow you across every repo instead; copy the output to whichever path matches your intent. CLAUDE.md and .mcp.json both sit at the repository root.
Claude Code's permission system is the reason this file exists. Two independent controls stack on top of each other, and the generator exposes both.
The first is permissions.defaultMode, the blanket posture for a session. The generator offers four values, and only writes the key when you choose something other than the default:
default — the agent asks before each action it has not been pre-authorised for. Nothing is written to the file; this is what you get by omitting the key.acceptEdits — file edits are auto-accepted, other tools still prompt. The usual choice once you trust the loop in a scratch branch.plan — read-only planning first. The agent explores and proposes before it is allowed to write anything.bypassPermissions — no prompts at all. Reasonable inside a disposable container, a poor idea on a machine with production credentials on it.The second is the rule list: permissions.allow and permissions.deny, arrays of tool-pattern strings. A rule is a tool name, optionally narrowed by a parenthesised pattern — Edit covers every file edit, Bash(git:*) covers any git subcommand, Read(./.env) covers exactly that file. The generator ships two defaults that are worth keeping: allow Bash(git:*) and Edit so ordinary work stops interrupting you, deny Read(./.env) and Read(./.env.*) so the agent cannot pull your local secrets into a transcript.
The chips you can toggle are:
| Allow list | Deny list |
|---|---|
Bash(git:*), Bash(npm:*), Bash(pnpm:*), Bash(make:*), Bash(docker:*), Edit, WebFetch, WebSearch | Read(./.env), Read(./.env.*), Read(./secrets/**), Bash(rm:*), Bash(sudo:*), Bash(curl:*) |
The pattern syntax is not limited to the chips shown. Once you have the shape, hand-edit the arrays — Bash(terraform apply:*), Read(./infra/**), Bash(psql:*) all follow the same form. Denying Bash(rm:*) and Bash(sudo:*) is cheap insurance if you also raise defaultMode: the deny list is the floor that the mode cannot lift.
Choose Sonnet as the model, acceptEdits as the mode, keep the default allow and deny chips, turn off the co-authored trailer, and turn on privacy hardening. The generator emits:
{ "$schema": "https://json.schemastore.org/claude-code-settings.json", "model": "sonnet", "permissions": { "defaultMode": "acceptEdits", "allow": ["Bash(git:*)", "Edit"], "deny": ["Read(./.env)", "Read(./.env.*)"] }, "includeCoAuthoredBy": false, "env": { "DISABLE_TELEMETRY": "1", "DISABLE_ERROR_REPORTING": "1", "DISABLE_AUTOUPDATER": "1" } }
Every key in that output is conditional, which is deliberate — a settings file that only states what you changed is far easier to review in a pull request than one that restates every default. Specifically: model appears only when you pick something other than "Account default"; defaultMode appears only when it is not default; allow and deny appear only when non-empty; includeCoAuthoredBy is written only as false, since true is already the behaviour; cleanupPeriodDays appears only when you move it off 30 days; and the env block appears only with privacy hardening on.
The model selector writes a plain model string. Alongside the individual tiers — opus, sonnet, haiku — there is opusplan, which uses the larger model while you are in Plan mode and drops to Sonnet for execution. That is the option people most often do not know exists, and it is usually the right default for long sessions: the expensive thinking happens where it pays off.
Transcript retention is cleanupPeriodDays, a number of days. The generator offers 7, 14, 30 and 90; 30 is the default, so selecting it writes nothing. Shorten it if local chat history on a shared machine is a concern.
The privacy toggle does not invent a setting — it writes an env block that Claude Code passes to its own process, setting DISABLE_TELEMETRY, DISABLE_ERROR_REPORTING and DISABLE_AUTOUPDATER to 1. The auto-updater one matters in environments where the CLI version is pinned by a package manager or a base image and a self-update would drift from it.
The .mcp.json tab writes an mcpServers object where each key is a server name and each value is a launch block. The generator knows eight servers: Filesystem, GitHub, Context7, Playwright, Memory, Sequential Thinking, Postgres and Brave Search. All eight launch over stdio through npx -y, so there is nothing to install first.
Two of them need credentials, and the generator writes the variable reference rather than a secret: GitHub emits "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}" }, Brave Search emits "env": { "BRAVE_API_KEY": "${BRAVE_API_KEY}" }. Export those in your shell and the committed file stays free of secrets. Two others carry placeholders you must edit: Postgres is generated with the connection string postgresql://localhost/mydb, and Filesystem is scoped to . — the current directory. Widen or narrow both before you rely on them.
One honest wrinkle: if you select no servers at all, the tab shows an empty { "mcpServers": {} } followed by two // comment lines reminding you that you can also add servers with claude mcp add <name> -- <command> [args...]. JSON has no comments, so delete those two lines before saving that file, or just do not save it — an empty .mcp.json achieves nothing anyway.
The CLAUDE.md tab is filled deterministically from four inputs: project name, primary stack, package manager and test command. It produces a Project section, a Commands section with install/dev/test/build/lint derived from your package manager, a short Conventions section, and Guardrails covering secrets and destructive actions. The package-manager control only appears for Node.js, Next.js and "Other" stacks, since it is meaningless for Go or Rust. Leave the test command blank and it falls back to <pm> test.
Beneath that tab — and only that tab — there is an optional AI panel. It is collapsed by default, it downloads nothing until you open it and explicitly ask, and when you do, it runs a small model such as Qwen2.5 1.5B or Llama 3.2 1B entirely in your browser over WebGPU. Your project description never leaves the device. It exists because a generated template can state your commands but cannot know that your migrations must run before your tests, or that a particular directory is generated and must never be hand-edited. Write a paragraph describing the project, and it rewrites the file around those specifics. If your browser lacks WebGPU the panel tells you so, and the deterministic template on the tab is unaffected — the AI is an optional overlay, never a dependency. Generated output replaces the tab contents with a visible "revert to template" link, so nothing is lost.
.claude/settings.json is project-scoped and only applies inside that repository. Check you are not sitting in a parent directory.Bash(npm:*) does not cover pnpm, and a git call buried in a shell one-liner with pipes may not match Bash(git:*) either. Add the specific pattern rather than widening the mode.npx package failed to resolve, or a required env var is unset — a ${GITHUB_TOKEN} that expands to nothing usually fails silently at connect time..mcp.json it will be committed with the rest. Keep using the ${VAR} form.Every file is copyable and downloadable from its tab, and Reset returns the whole form — including any AI-generated context file — to defaults. If you are wiring the same MCP server into several different clients rather than configuring Claude Code itself, the MCP server config generator covers that shape instead.