Claude Code tips to work faster

Claude Code rewards a little setup. A handful of habits turn it from "watch it work" into "let it work while you do something else". Here are the ones that pay off fastest.

1. Let it run the safe things unattended

The biggest speed-up is not typing faster. It is not being asked so often. Widen permissions.allow for the repetitive, safe actions and tighten permissions.deny around secrets and destructive commands:

{
  "permissions": {
    "allow": ["Bash(npm run test:*)", "Bash(npm run lint)", "Read(./src/**)"],
    "deny": ["Read(./.env*)", "Bash(rm:*)"]
  }
}

The agent stops interrupting you for the boring stuff and only stops for what actually matters. See your Claude Code settings.json, explained.

2. Write a CLAUDE.md and keep it short

A CLAUDE.md at the root of your repository is read at the start of every session. It is where you put the things you would otherwise repeat in every prompt: how to run the tests, which package manager the project uses, the conventions your codebase actually follows. Keep it to what is not obvious from the code, because everything in it costs context on every single turn. Press # during a session to append a line to it without leaving the terminal.

3. Scope prompts narrowly

An agent told to "improve the app" wanders; one told to "add pagination to the users table" ships. Narrow, well-bounded tasks finish faster, are easier to review, and are safe to run in parallel.

4. Plan first on anything non-trivial

For a change that touches several files, ask for the plan before the edits. Plan mode (cycle to it with shift+tab) lets the agent explore and propose without touching anything, which is far cheaper than reviewing a wrong diff. Approve the plan, then let it run.

5. Run several at once with worktrees

Once tasks are narrow, run them in parallel. Git worktrees give each agent its own branch and folder so they never collide, the clean way to have three sessions going at once. Full walkthrough in Claude Code with git worktrees.

6. Turn repeated prompts into slash commands

Any prompt you have typed three times belongs in .claude/commands/. A file named review.md becomes /review, and $ARGUMENTS carries whatever you type after it:

---
description: Review the current diff for bugs and missing tests
---

Review `git diff` for correctness bugs and missing test coverage.
Focus on $ARGUMENTS. Report findings only, do not fix anything.

Commit them and your whole team gets the same shortcuts.

7. Wire hooks for awareness

Use Claude Code hooks so the terminal reaches you instead of the other way round: a Stop hook to know a run finished, a Notification hook to know one is blocked on you. Even a one-line sound when it finishes lets you look away with confidence. A PostToolUse hook running your formatter after every edit is the other easy win: the agent stops producing diffs full of whitespace noise.

8. Keep the context lean

Long, sprawling sessions get slower and compact more. Start fresh sessions for unrelated tasks rather than piling everything into one: /clear wipes the context to start clean, /compact summarises it when you want to carry on, and /context shows you what is actually filling the window. Shorter turns mean more finished work and less to hold in your head.

9. Delegate the wide reading

When a task means searching across the codebase or checking twenty files, let the agent fan out to subagents. They read in their own context and hand back a summary, so your main conversation stays about the change you are making rather than the forty files that turned out to be irrelevant.

10. Resume instead of re-explaining

You rarely need to rebuild context from scratch. claude -c picks up the last session in the current directory, and claude --resume lets you choose from earlier ones. When you come back to a task the next morning, that is a lot cheaper than pasting the background again.

11. Review the diff, not the summary

The agent's account of what it did is a summary, and summaries are where mistakes hide. Read git diff yourself before committing, and commit in small enough steps that the diff stays readable. A session that ran for twenty minutes and produced one enormous commit is a session you cannot really review, however good it was.

12. Script the one-shot jobs

Not everything needs an interactive session. claude -p "…" runs a single prompt and prints the answer, which makes it usable from a shell script, a git hook or a CI job: generating a changelog entry, summarising a diff, triaging a log file. Combine it with --output-format json when something downstream has to parse the result.

13. Stop babysitting the terminal

The habit that quietly costs the most is checking: alt-tabbing to see whether a run is done or stuck. That is the exact thing Blooby removes. It gives each Claude Code session a live desktop mascot (busy while it works, looking up when it needs you, celebrating when it finishes), so awareness becomes a glance instead of a task. It sets up its own hooks, needs no account, and works across as many sessions as you run.