For those of us whose AI use is measured in hours per day, the novelty has worn off. We’ve internalized the idea that work once measured in weeks or months can now happen in minutes. That recalibration happened fast. What I didn’t expect was the next phase: impatience with the AI itself.
I catch myself doing it constantly. Waiting on Claude to finish summarizing a meeting transcript, drafting an email response, or researching a topic — and finding myself annoyed that it’s taking thirty seconds instead of fifteen. The bar moved, and it moved inside my own head without me noticing.
For those clerical tasks — the ones where I’m not building software, not writing code that needs careful review — I have a favorite setting:
claude --dangerously-skip-permissions
What It Does
By default, Claude Code asks permission before doing almost anything beyond reading files. Run a bash command? It asks. Edit a file? It asks. Fetch a web page? It asks. Each prompt is a guardrail — a moment to verify the AI is about to do what you actually intended.
--dangerously-skip-permissions turns all of that off. Claude runs uninterrupted until the task is complete. No confirmation dialogs. No “Allow this command?” prompts. No pause between thinking and doing.
The name is intentional. Anthropic didn’t call it --auto-approve or --unattended. They called it dangerously skip permissions, because that’s what it is.
Where I Use It
Research is the obvious one. When I ask Claude to investigate a topic across multiple web sources, the default behavior means approving every single fetch individually. For a task that might hit twenty URLs, that’s twenty interruptions where I’m clicking “yes” repeatedly. With the flag, I type the prompt, lean back, and come back to a finished summary.
Meeting prep works the same way. “Read these five documents and build me a briefing.” Without the flag, that’s five permission prompts to read, plus whatever commands Claude needs to organize the output. With it, the work just flows.
Email drafting. Document summarization. Status reports from multiple sources. Any task where I know the inputs, trust the outputs, and the worst-case scenario is that I don’t use what it produces.
Where I Don’t
Software builds are a different story entirely.
Imagine asking Claude to scaffold a new project: create the directory structure, install dependencies, configure a build pipeline, run the initial build. That’s a chain of bash commands creating directories, writing config files, downloading packages from the internet, and executing code on your machine. Every step is a place where a misunderstood instruction could do real damage — and without permission prompts, there’s nothing between the misunderstanding and the consequence.
Or picture a database migration. “Update the schema and migrate the data.” Without guardrails, there’s no checkpoint between Claude’s interpretation of that sentence and an ALTER TABLE on your production database. One ambiguous prompt, and you’re restoring from backup.
The pattern is straightforward: if the task only reads and produces text, the flag saves time. If it writes to disk, runs system commands, or touches anything you can’t easily undo — keep the guardrails on.
The Irony
A year ago, I was marveling that AI could draft a PowerShell script in seconds that would have taken me an afternoon. Now I’m disabling its safety features because the permission prompts slow me down.
That’s the thing about speed. You never get used to it. You just get used to wanting more of it.