Code

DeutschlandGPT Code is a coding assistant that works directly in your project. It reads and changes files, runs commands in a real terminal, uses Git, and can show a running dev server in a preview. All of it on your machine, in the folders you shared with it.

Code and Cowork share the same engine and the same approval model. Code adds what a development workspace needs: terminal, Git, preview and project instructions.

Getting started

If no conversation is open, Code starts on a page that lists your sessions, the open pull requests of your shared folders and due reminders. Overview and history explains it.

The shared folders of Code and Cowork are kept separate: a folder you shared with Cowork is not reachable from Code, and the other way round.

What it can do

Area	Details
Read the project	Full-text search, name patterns, directory listings, files read in windows so a huge file does not have to be swallowed whole
Change code	Targeted edits, new files, moving, renaming, deleting
Run commands	Build, test, lint, Git, package managers, anything else in a real terminal
Long-running commands	A dev server or a watch task keeps running in the background
Git	Status, diff, staging, commits, branches, remotes, fetch, pull, push, pull requests through the GitHub CLI
See the result	A live preview of a running dev server, plus screenshots and the browser console of that page
Delegate work	Hand a question or a whole sub-task to a sub-agent
Documents	Everything Cowork can do with Office files and PDFs, since the two share the same toolset

Below the composer

The bar under the input field describes the next turn:

• + attaches images and files.
• Tools shows whether Web Search is available with the current model, switches on Image Generation (if an image model is available to you; on request the assistant saves a generated image or a diagram as a file in your project), and narrows which Integrations the assistant may reach.
• The model menu shows model and effort in one button. Pick the model at the top and the effort in the Effort submenu. Both are remembered per conversation.
• The mode decides how much runs without asking, see below.

In the header, the Special app picker binds one of your special apps to the conversation. The choice takes effect with the first message and stays with that conversation. For a different special app, start a new chat.

Permission modes

The mode can be switched at any time, also with Cmd/Ctrl+Shift+M.

Mode	Behaviour
Plan mode	Reads only, produces a plan. Changes and commands are blocked
Normal	Asks before changes, deletions and commands
Accept edits	File changes run without asking. Commands and external tools still ask
Auto	Everything runs without asking

Before Accept edits or Auto takes effect, the app spells out what that means and asks you to confirm.

Plan mode is the safe way into an unfamiliar codebase: let it produce a plan first, read it, then switch modes and have it done. The assistant writes its plan to .deutschlandgpt/plans/ and then asks explicitly whether to implement it, so approving the plan is a deliberate step and not a side effect of your next message.

Critical commands

A force push, reset --hard, rm -rf, anything under sudo, piping a downloaded script into a shell, publishing a package: in Normal and Accept edits these always produce an approval card with the reason. A standing permission does not cover them, and the card offers no "always allow".

What Auto really means

Auto is the same assistant with the questions turned off. It writes, moves and deletes files, and it runs commands, critical ones included, without a confirmation each time. The confirmation dialog says so before you switch.

What stays in place:

• The file tools stay inside the shared folders. That boundary is enforced by the app, not by the mode, and widening it is a separate switch under Data storage.
• A sub-agent still asks in Auto when it wants to run a critical command or touch a path outside the shared folders. You did not watch it decide on that call, so the app asks you.

Auto fits a scratch branch you can throw away. On a branch you care about, Accept edits gives you nearly the same speed while every command still stops and asks.

Approvals

A command or file change appears as an approval card with the actual diff or the actual command line.

Key	Action
Cmd/Ctrl+Enter	Approve
Cmd/Ctrl+Shift+Enter	Approve everything pending
Esc	Decline
Alt+1 to Alt+9	Select a card when several wait
Alt+Up / Alt+Down	Move the selection

"Always allow" is always narrow. For a file action it binds to that kind of action in one shared folder. For a command it binds to that command family, so approving pnpm test once does not approve everything. The Permissions menu in the header lists what you granted, with Revoke per entry and Revoke all. When you stop sharing a folder, its permissions are revoked too.

Actions of connected services, so integrations and MCP servers, have their own gate on the server side. Approve connections automatically lets them through independently of the file gate.

Delegating to sub-agents

The assistant can hand work to a sub-agent that runs in its own context and reports back:

• Explore only reads. It searches the project for an answer and returns it as a card in the conversation, folded so it does not take over the transcript.
• Agent is a full sub-agent for a self-contained sub-task. Its row shows progress while it works, and afterwards the brief and the result. It can also run in the background while the main conversation goes on.

Every tool a sub-agent calls passes the same approval gate as the assistant's own calls.

Talking to a running assistant

• Send while it works. Your message joins the running turn at the next step boundary, so "no, use the existing helper instead" arrives while the work is happening rather than after it. A pending approval or a slash command waits for the current step first.
• Several messages in a row are queued visibly and dispatched in order. Send now on a queued message stops the current turn and sends that message right away.
• Stop ends the turn. Work already done stays done.
• If a turn runs out of steps with work left, a card asks whether it should keep going. Keep working resumes the same turn with every step intact. How many steps one instruction may take is set under Settings for Code.

The task list

For a multi-step job the assistant keeps a list of its steps, each with its state. As soon as there is one, a Plan icon appears at the left of the panel icons in the header and opens the list as a pane. The panel does not open by itself: when the list changes while you are not looking, the icon gets a dot.

Switch it off with Show task list under Chat settings.

Undoing a change

Code keeps no file versions of its own. Git is the safety net here: commit before a larger change, look at the diff in the Git pane, and have the assistant revert what you do not want. The Git graph can also revert a commit or reset a branch.

Settings for Code

The Code tab in the settings holds three options for this device:

• Font size: the text size of the transcript, in Code and Cowork alike.
• Max. steps per instruction: how many steps Code takes for one instruction before it pauses and offers Keep working. Empty means Unlimited.
• Keep computer awake while DeutschlandGPT works: prevents sleep while Code or Cowork is working, with a second switch Keep awake on battery power. For a single conversation, the same option sits in its menu in the history as Keep computer awake.

More