Approve Claude Code without switching terminal windows

Why this hurts more than it should

A permission prompt is a blocking question in a window you are not looking at. So the interruption is not the two seconds of reading the command. It is the minutes between the agent stopping and you noticing, plus the reload cost of getting back to whatever you were doing. Run three sessions at once and the pattern becomes a loop: check, check, check, in case one of them is stuck.

Cutting that down has two independent levers. Fewer prompts is the first and it is free. Answering faster is the second.

Lever one, part one: the permission mode

Claude Code has a permission mode that governs how eagerly it asks. Shift+Tab cycles through them mid-session, and the current one is shown in the status line.

• Default. Asks before each new kind of action. This is the mode to stay in for anything touching a repo you care about.
• Plan mode. The agent may read and reason but may not edit files or run commands. Useful at the start of a task: let it produce the plan without any prompt at all, approve the plan once, then let it work.
• Accept edits. Stops asking before file edits while still asking about other tools. Good for a branch you are prepared to throw away, uncomfortable anywhere else.
• Bypass permissions. Skips the checks. Only sane inside a container or a VM you can discard, and it is the one mode where the phrase "it deleted the wrong thing" stops being hypothetical.

Plan mode is the underrated one. A large share of the prompts in a session come from the exploratory phase, and plan mode removes all of them by design.

Lever one, part two: an allowlist that fits your project

The durable fix is telling Claude Code which specific things it never has to ask about. These live in the permissions block of a settings file, and they are pattern-matched against the tool call:

Three files can hold these, in increasing specificity: ~/.claude/settings.json for you personally, .claude/settings.json for the project and everyone on it, and .claude/settings.local.json for the things that are yours alone and should stay out of git.

You rarely need to write them by hand. When a prompt appears, one of the answers is the durable one: allow this always. Choosing it writes the rule into the project's own settings for you. The trick is to actually choose it for the commands you know you will approve fifty more times, instead of pressing plain yes on autopilot.

Deny rules are worth writing too, and they are stronger than allow rules. A deny entry for destructive patterns holds even in a session where you got sloppy with the mode.

Lever two: the prompts that should still exist

After a good allowlist, what is left is exactly what you want left: the migration against staging, the force push, the file outside the project, the command you have never seen this agent run before. Those should interrupt you. The problem is not that they ask, it is where they ask - in a terminal tab that may be behind three windows on another Space.

Notifications are the usual answer and they are half of one. A banner tells you a session is waiting; you still have to go there. The notifications guide covers how to set those up properly, including a hook that posts a real macOS banner from any terminal.

Answering in place

The reason answering in place is possible at all is mechanical. A Claude Code permission hook blocks on a local Unix socket while it waits for a decision. Anything attached to that socket can send the decision back, and the prompt resolves where it stands.

Noveriq is a native macOS app built on exactly that. Every running session appears in the MacBook notch, the ones waiting on a human sort to the front, and the card carries the actual command. You press Allow or Deny there. Your terminal never comes forward and nothing is typed into it; there is deliberately no synthetic-keystroke path anywhere in the app.

It offers the same three answers the terminal does, which matters for this guide specifically: allow once, allow for the rest of this session without writing anything to disk, or always - which writes the durable rule into the project's own settings, the same file you would have edited by hand above. So the fast path and the allowlist are the same action.

Destructive shell commands are flagged on the card before you press anything, so a quick Allow stays a considered one.

It is $9.99 once for one Mac, no subscription, macOS 15 or later, 30 days money back. It speaks natively to Claude Code, Codex, Cursor, Gemini CLI, Qwen Code and opencode.

The order to do this in

1. Start tasks in plan mode. Approve one plan instead of twenty steps.
2. For a week, take the always option on every prompt you would obviously approve again. Your allowlist will write itself.
3. Add deny rules for the things nothing should ever do in this repo.
4. Only then decide whether the prompts that remain need a faster surface. If you run one session at a time, they probably do not.

Questions

Will an allowlist make the agent riskier?

Only if the rules are broad. A narrow rule encodes a decision you have already made repeatedly. A broad one hands over decisions you have not made yet.

Where should project rules live, committed or local?

Commit anything the whole team would agree with, such as the test and lint commands. Keep personal shortcuts in .claude/settings.local.json so nobody inherits your risk tolerance.

Does answering from an external app send keystrokes to my terminal?

It does not have to. Noveriq answers over the socket the hook is already blocking on, so nothing is typed anywhere. Be wary of any tool that solves this by simulating keypresses into a window.

Does this work with several sessions at once?

Yes. Each running session gets its own card, and the ones waiting on a human come to the front, which is the part that removes the check-check-check loop.