Claude Code Manual Permission Mode for Game Developers - What Changed in 2026

Claude Code permission mode is no longer a hidden default with a confusing name. In v2.1.200 (July 3, 2026), Anthropic renamed what humans used to call default to Manual across the CLI, VS Code, JetBrains, and desktop surfaces. The config value is still default for hooks and SDK integrations — but manual is now an accepted alias, and the UI finally matches the behavior: you approve each tool call by hand unless you deliberately loosen the session.

That rename matters for game developers because Claude Code is already a top terminal agent on real repositories. A JetBrains survey of more than 10,000 professional developers reported 18% work adoption for Claude Code — the same tier as Cursor. Those sessions touch Unity C#, Godot GDScript, Unreal C++, build scripts, CI YAML, and increasingly MCP bridges into editors. One wrong acceptEdits afternoon on a ship branch can corrupt Library/, .godot/, or Binaries/ faster than a human can Ctrl+Z.

This article maps which mode to use when, how to commit team-safe .claude/settings.json rules for engine repos, what the AskUserQuestion stall means for CI, and how to file claude_permission_mode_receipt_v1.json before you call a workflow production-ready. For MCP-specific allowlists, pair this with our Unreal Engine 5.8 MCP safe session guide. For the broader assistant lineup, start with best AI coding assistants 2026.

Why this matters now

Three July 2026 changes collided for teams running Claude Code on game repos:

1. Manual label clarity — v2.1.200 renames default to Manual in every human-facing surface while keeping default as the canonical config value. --permission-mode manual and "defaultMode": "manual" now work alongside the legacy strings.
2. AskUserQuestion no longer auto-continues — interactive clarifying dialogs wait for you instead of timing out and advancing. That closes a foot-gun in supervised sessions but breaks unattended CI and background daemon runs that relied on silent timeout behavior.
3. Permission docs caught up — Anthropic's permission modes guide now documents the full ladder (default/manual, acceptEdits, plan, auto, dontAsk, bypassPermissions) with engine-agnostic examples teams still have to translate into Unity/Godot/Unreal boundaries.

Evidence note: Primary keyword Claude Code permission mode. Demand signals include 138K+ GitHub stars on the official release surface and sustained professional adoption in the JetBrains AI Pulse. SERP gap: rename explainers exist; game-repo governance — folder deny lists, MCP write tiers, CI stall fixes, and receipts — does not.

Non-repetition: This is not the 14-assistant comparison matrix, not the Unreal MCP setup tutorial, and not the Aider Git workflow or Qwen approval-mode guide. Same safety theme, different product surface — Claude Code session permission posture after the July rename.

Who this guide is for

Time: about 30–45 minutes for the beginner path; add 20 minutes to commit a team settings file and receipt.

Permission modes at a glance (July 2026)

Anthropic's official mode table defines what runs without a prompt:

Manual requires Claude Code v2.1.200+ for the label and manual alias. In every mode except bypassPermissions, writes to protected paths (including Claude's own config) are never auto-approved.

Game-dev default recommendation: start Manual on any branch that can reach production. Escalate to plan for exploration, then acceptEdits only after scope is explicit. Treat auto as a earned privilege on isolated worktrees — not day-one ship-branch policy.

What changed in v2.1.200 (and what did not)

Renamed, not rewritten

The behavior you knew as default is the same read-only without prompts, approve everything else posture. What changed is labeling and aliases:

# Both valid at startup (v2.1.200+)
claude --permission-mode manual
claude --permission-mode default

{
  "permissions": {
    "defaultMode": "manual"
  }
}

Hooks and SDK integrations should keep emitting default until your team standardizes on manual in human-run configs. Mixed teams: document that Manual in the UI equals default in JSON.

AskUserQuestion stall (CI-breaking)

Previously, when Claude Code asked a clarifying question mid-run, the dialog could auto-continue after idle timeout. In v2.1.200 it waits for a human unless you opt into idle timeout via /config.

Impact on game pipelines:

• Background daemon sessions that hit a clarifying question will hang until someone answers.
• CI jobs wrapping claude -p may freeze on the first ambiguous asset path or engine version question.
• Subagent orchestration where the parent expects silent progress needs tighter system prompts or pre-approved tool rules.

Fix paths:

1. Pre-approve narrow Bash patterns for your build/test commands in .claude/settings.json.
2. Add system-prompt lines: "Do not use AskUserQuestion; state assumptions in the plan and proceed with the safest read-only alternative."
3. For truly unattended jobs, evaluate dontAsk with an explicit allow list — not bypassPermissions on a networked dev machine.
4. Opt into idle timeout via /config only when a human is nearby to catch wrong assumptions.

Beginner path - one evening on a throwaway branch

Prerequisites

• Claude Code v2.1.200+ (claude --version).
• A Git game repo clone you can afford to break.
• A disposable branch — never main, release/*, or your fest demo branch.
• 30 minutes and a beverage.

Step 1 - Confirm Manual mode

Launch in the repo root:

git checkout -b claude-permission-smoke-2026-07-20
claude --permission-mode manual

Press Shift+Tab and watch the status badge. You should see Manual / default in the cycle before acceptEdits and plan. On builds before v2.1.203, Manual may show no badge — behavior is still read-gated.

Step 2 - Run a read-only smoke task

Example prompt (Godot-flavored; swap paths for your engine):

Read only. List the five highest-risk folders in this repo for an AI agent to touch accidentally. Do not edit files or run destructive shell commands. Propose a safe first script-only task for a pause-menu volume setting.

You should get a plan without write prompts. If Claude asks to edit, deny and restate Manual boundaries.

Step 3 - Switch to plan mode for exploration

Press Shift+Tab until plan is active, or restart with:

claude --permission-mode plan

Ask it to map where audio bus code lives and which tests exist. Plan mode researches and proposes without applying edits — ideal before you trust acceptEdits on gameplay code.

Step 4 - Escalate to acceptEdits for one bounded write

When scope is explicit, cycle to acceptEdits and say:

Implement only the volume getter/setter in scripts/audio_manager.gd. Do not touch scenes, .import, or .godot/. Stop after one logical change.

Review every diff. If Claude reaches for project.godot or bulk asset paths, deny and narrow.

Step 5 - Run one targeted verification command

Approve only the test command you expect — for example:

godot4 --headless --path . -s addons/your_plugin/test_volume.gd

Do not blanket-approve rm, git push, or package publishes on your first evening.

Common beginner mistakes

• Starting in acceptEdits because Manual feels slow — speed without boundaries is how Library/ diffs happen.
• Approving auto because a influencer thread said to — auto mode has account requirements and weaker human oversight.
• Assuming the July rename changed safety — it changed labels, not the need for engine-side verification.

Developer workflows - team settings, engine boundaries, MCP

Workflow 1 - Commit .claude/settings.json per repo

Project-scoped settings live in .claude/settings.json at the repo root (committed for team alignment). Example skeleton for a Unity + CI repository:

{
  "permissions": {
    "defaultMode": "manual",
    "allow": [
      "Bash(dotnet test:*)",
      "Bash(git status)",
      "Bash(git diff:*)"
    ],
    "deny": [
      "Read(./Library/**)",
      "Read(./Temp/**)",
      "Read(./.env*)",
      "Bash(git push:*)",
      "Bash(rm -rf:*)"
    ]
  }
}

Godot additions: deny Read(./.godot/**) and Read(./.import/**) unless you have a deliberate reason. Unreal additions: deny Binaries/, Intermediate/, Saved/, and derived data caches.

Layer allow rules for the three commands your team runs every session. Keep deny aggressive on generated engine output and secrets.

Workflow 2 - Mode ladder by branch type

Document the ladder in your team README so contractors do not import personal bypassPermissions habits.

Workflow 3 - MCP write tools are a second gate

Text edits are only half the risk. When you enable Unreal MCP or Unity MCP with Cursor, MCP tools can move editor state Claude Code cannot see in a flat diff.

Rules:

1. Keep Claude Code in Manual or plan until MCP read tools pass smoke.
2. Allowlist one write tool at a time; undo in-editor before expanding.
3. Never combine bypassPermissions with Experimental MCP on a networked machine.
4. File separate MCP receipts — permission mode alone does not prove editor safety.

Workflow 4 - Pair with Git-native recovery tools

Claude Code auto-commits in some workflows; many teams still prefer explicit Git discipline. If you want instant /undo semantics on script-only lanes, compare our Aider Git workflow. If you want sub-agent delegation with Qwen-style approval modes, see Qwen Code CLI workflows. Claude Code remains the deepest terminal harness — if permission posture is configured before autonomy.

Workflow 5 - VS Code and JetBrains parity

The VS Code extension shows Manual, Edit automatically (acceptEdits), Plan, Auto, and Bypass permissions in the mode selector. JetBrains delegates to the embedded terminal — same Shift+Tab cycle as CLI. Enterprise rollouts should pin extension versions alongside CLI so forceLoginMethod and permission labels stay aligned with IT docs.

Four engine-specific patterns

Pattern A - Unity script refactor (C# only)

1. Manual mode — read-only audit of Assets/Scripts/Combat/.
2. plan mode — propose interface extraction without touching .unity / .prefab.
3. acceptEdits — one .cs file change.
4. Human opens Unity for play-mode smoke — agent diff is not ship proof. Cross-check Cursor Unity pair programming contract gates.

Pattern B - Godot gameplay tweak

1. Deny .godot/ and .import/ in settings.
2. plan mode maps autoload and signal paths.
3. acceptEdits on one .gd file.
4. Headless test or one-scene run before merge.

Pattern C - Unreal build script hardening

1. Manual mode reviews Build.cs and CI YAML read-only.
2. acceptEdits applies one guard (cache key, artifact path).
3. Keep Blueprint and map changes human-owned; use MCP only with UE 5.8 allowlist tiers.

Pattern D - Documentation after a feature branch

1. plan mode drafts changelog from git diff main...HEAD.
2. acceptEdits updates CHANGELOG.md only — no gameplay code in the same session.

Governance gates C1–C6 (company and team leads)

Diligence paragraph for partners: Claude Code is operator-controlled terminal software. Data handling depends on Anthropic plan terms, API routing, and what you paste into prompts — not the permission label alone. Treat file paths, crash logs, and unreleased design notes as sensitive. Prefer branch isolation, Manual defaults on shared branches, human merge approval, and engine-side verification. The July 2026 rename improves clarity; it does not replace code review, binary artifact governance, or MCP undo discipline.

Verification receipt - claude_permission_mode_receipt_v1.json

Save when a repo graduates from "we tried Claude Code" to "we have a policy":

{
  "schema": "claude_permission_mode_receipt_v1",
  "project": "your-game-repo",
  "date": "2026-07-20",
  "claude_code_version": "2.1.200+",
  "default_mode": "manual",
  "mode_ladder": ["manual", "plan", "acceptEdits"],
  "settings_path": ".claude/settings.json",
  "deny_paths": ["Library/", ".godot/", "Binaries/"],
  "mcp_enabled": false,
  "ask_user_question_policy": "no_unattended_runs",
  "ci_permission_mode": "dontAsk",
  "gates": {
    "C1_version_pinned": true,
    "C2_default_explicit": true,
    "C3_engine_denies": true,
    "C4_ask_policy": true,
    "C5_mcp_tiered": true,
    "C6_receipt_filed": true
  },
  "smoke_task": "Manual read-only repo risk map, plan-mode audio scan, one acceptEdits script write",
  "engine_verify": "headless_or_play_mode_pass",
  "result": "pass",
  "operator": "session-owner-handle"
}

Set "result": "pass" only after human review and engine verification where relevant.

Compare Claude Code permission posture to nearby tools

Key takeaways

1. Manual is the new human-facing name for Claude Code's original default mode — config value unchanged, manual alias added in v2.1.200.
2. AskUserQuestion no longer auto-continues — fix CI and daemon stalls with allow rules, prompts, or explicit dontAsk policies.
3. Start every ship-adjacent branch in Manual; use plan to explore and acceptEdits only after scope is explicit.
4. Commit .claude/settings.json with aggressive denies on engine generated folders and secrets.
5. MCP write tools need a second allowlist tier — permission mode alone does not protect editor state.
6. auto and bypassPermissions are not beginner modes on networked dev machines with real assets.
7. File claude_permission_mode_receipt_v1.json with gates C1–C6 before calling the workflow team policy.
8. Engine verification still beats diff green — scenes, prefabs, binaries, and play mode remain human gates.

Frequently asked questions

What is Claude Code Manual permission mode?

Manual is the July 2026 human-facing label for Claude Code's original default permission mode. Claude may read files freely but must ask before edits, shell commands, or network requests. The config value remains default; manual is an accepted alias in v2.1.200+.

What changed in Claude Code v2.1.200 for permissions?

Anthropic renamed default to Manual in the CLI, VS Code, and JetBrains UIs; added manual as a config alias; and stopped AskUserQuestion dialogs from auto-continuing by default. Behavior is clearer; unattended pipelines need updated policy.

What is the difference between Manual and acceptEdits in Claude Code?

Manual (default) prompts before every write and command. acceptEdits auto-approves file edits and common filesystem operations like mkdir and mv while still prompting on risky shell commands. Use Manual on unfamiliar branches; use acceptEdits only when you are actively reviewing each change.

How do I set Claude Code permission mode for a Unity or Godot project?

Add .claude/settings.json at the repo root with "defaultMode": "manual", allow narrow test/build commands, and deny generated folders (Library/, .godot/, .import/). Launch with claude --permission-mode manual or cycle modes with Shift+Tab mid-session.

Why did my Claude Code CI job hang after July 2026?

AskUserQuestion dialogs no longer time out and auto-continue. If your pipeline triggers a clarifying question, the job waits forever. Use dontAsk with explicit allow lists, tighten prompts to forbid AskUserQuestion, or pre-approve the commands your CI needs.

Is Claude Code auto mode safe for game development?

Auto mode reduces prompts using background safety checks but requires account eligibility and weakens moment-by-moment human oversight. It is inappropriate for first sessions on production-adjacent branches. Prefer Manual → plan → acceptEdits until team settings and receipts are in place.

How does Claude Code permission mode relate to MCP tools?

Permission modes govern Claude Code's built-in tools. MCP servers (such as Unreal Editor bridges) expose separate tools that can edit engine state. Keep Claude Code in Manual or plan until MCP read smoke passes; expand write allowlists one tool at a time.

Conclusion

The July 2026 rename is good news disguised as a changelog bullet. Manual tells the truth about what default always meant — and the AskUserQuestion fix forces teams to stop pretending unattended agent runs were safe because a dialog used to time out.

Tonight: one branch, Manual mode, one read-only risk map, one plan-mode exploration, one acceptEdits write you actually reviewed, one engine smoke, one receipt. Then compare your posture against the full AI coding assistant field before you loosen modes on the branch that ships your next demo.

Related reading and sources

• Claude Code permission modes documentation
• Claude Code changelog
• Claude Code v2.1.200 release notes
• JetBrains AI coding tools survey 2026
• Stack Overflow agents-on-a-leash pulse
• Best AI coding assistants 2026
• Unreal Engine 5.8 MCP safe session
• Aider safe Git workflow for game dev
• Qwen Code CLI workflows
• AI resources for game developers