Claude Code: a checklist of best practices for daily work

Most Claude Code advice follows from one constraint: the context window fills up fast, and as it grows the model makes more mistakes and the work gets more expensive. So good habits boil down to giving the agent exactly what it needs, checking the result and not letting a task drift for long. Below is a Claude Code best practices checklist for daily work. Each item explains why it matters. It relies on Anthropic's official documentation (Best practices, Common workflows, Costs); check command names against your version, as they change.

1. Set up the connection and model slots first

If you work through a gateway, put the address, key and model slot mapping in ~/.claude/settings.json once. Per the Zukko Claude Code documentation↗: ANTHROPIC_BASE_URL=https://api.zukko.pro (without /v1), ANTHROPIC_AUTH_TOKEN=fetch_..., and the Opus, Sonnet and Haiku slots are remapped with the ANTHROPIC_DEFAULT_*_MODEL variables.

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.zukko.pro",
    "ANTHROPIC_AUTH_TOKEN": "fetch_...",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-opus-5-5",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-5-5",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-sonnet-5-5"
  }
}

Why: the aliases in the /model menu point to default models, and without remapping some slots (Haiku, for example) may point to a model that is not in the gateway's catalogue. If the file already exists, merge the env block rather than overwriting the config.

2. Keep a short CLAUDE.md

The CLAUDE.md file in the project root is loaded at the start of every session. The /init command creates a draft from the repository contents. What to put in: build and test commands, directory layout, conventions that cannot be guessed from the code. What to leave out: retelling the obvious, long manuals, secrets.

Example:

## Project
- Build: `npm run build`; tests: `npm test -- --run`
- TypeScript, strict mode; imports only through the `@/` alias
- Do not edit DB migrations by hand, only via `npm run migrate:new`
- Before finishing a task, run the linter and tests

Why: the file is paid for in every session, so each extra line costs money and dilutes what matters. More in How to write CLAUDE.md↗.

3. Give the agent a way to check its own work

The strongest habit from Anthropic's documentation: specify a check the agent can run itself. Not "implement email validation" but "implement validateEmail, here are examples: user@example.com is valid, user@.com is not, run the tests after implementing".

Why: without a check the agent has one signal, "looks done", and you become the verifier. With tests, a build or a linter it closes the loop itself: runs, reads the result, fixes.

4. Explore, then plan, then write

Plan mode is turned on with Shift+Tab (repeat until plan mode appears in the status line) or by starting claude --permission-mode plan. In it the agent reads files and proposes a plan but makes no edits until you approve. The typical order: explore, plan, implement, commit.

Why: you catch a wrong understanding of the task before it turns into ten modified files. A rule from the documentation: if the diff can be described in one sentence (a typo, a log line, a rename), no plan is needed.

5. Split the work into small tasks

One session, one task. "Rewrite the auth module" is better broken into "describe the current flow", "add token validation", "update the tests". Run /clear between unrelated tasks.

Why: the context accumulates file reads and command output that the next task does not need but pays for on every step. Per the documentation, if you have corrected the agent more than twice on the same issue, the context is cluttered with failed attempts: better to /clear and write a new, more precise prompt.

6. Write precise requests

Name the file, the symptom and the completion criterion. Compare "add tests for foo.py" with "write a test for foo.py for the case when the user is not logged in, without mocks". Point to examples in the code: "do it the way HomeWidget is done".

Why: less wandering around the repository and fewer tokens spent reading the unnecessary.

7. Manage context by hand

Automatic history compaction fires as you approach the limit, but doing it by hand is better. The /compact command takes a hint: /compact Keep the list of changed files and the test commands. You can also pick a message through /rewind and compact history before or after it. Compaction instructions can be written into CLAUDE.md.

Why: you decide what must survive compaction instead of leaving it to automation at an awkward moment.

8. Always look at the diff

Before committing, run git diff and read the changes. Ask the agent to explain non-obvious spots rather than accepting by default. Commit in small steps so a rollback is cheap.

Why: an agent sometimes solves a task "around" the problem, for example edits a test instead of the code or adds a stub. These things are visible only in the diff. A separate branch per task makes rollback safe; in addition, Claude Code has state rollback through /rewind or a double Esc.

9. Tune permissions to your work

Do not click "allow" blindly and do not switch confirmations off entirely. It is better to add narrow repeating commands (linter, tests) to permissions.allow and block secret files in permissions.deny, for example Read(./.env). For dangerous modes and secrets see the Permissions section of Anthropic's documentation.

Why: if confirmations appear only on rare and risky actions, you read them carefully. When there are too many, people start clicking through without looking.

10. Delegate research to subagents

When you need to "study how a module works", hand it to a subagent: it reads dozens of files in a separate context and returns a short summary. The main session stays clean. More in Subagents in Claude Code↗.

Why: reading files is the main consumer of context, and it is better to pay for it in a disposable window.

11. Pick the model for the task

Not everything needs the strongest model. From the table as of October 18, 2026 (Zukko, $ per 1M tokens, input / output, intelligence index): claude-opus-5-5 0.8 / 4, index 58; claude-sonnet-5-5 0.4 / 2, index 48. Change the model with /model at task boundaries, not in the middle of a long session: the cache is tied to the prefix and, as a rule, to the model, and after a switch the accumulated context is billed again. Which model copes with your tasks is shown only by testing on your own examples.

12. Watch spend and put a limit on the key

The /usage command shows session spend. Keep in mind that Claude Code computes the sum locally at Anthropic's list prices, so it is an estimate, not a bill; through a gateway it will not match actual charges. See actual charges on the Usage page of the Zukko dashboard. In the Anthropic format (/v1/messages, which Claude Code uses) the gateway sees cache reads and writes and bills them at their own prices: for claude-sonnet-5-5 that is $0.05 for a read and $0.5 for a write versus $0.4 for regular input.

Create a separate key for Claude Code in the dashboard↗ with a daily limit and an allowed_models list. If the agent loops, you get a 429 key_daily_limit_reached instead of a surprise on the balance. Limits are soft: a request started before the ceiling completes, so leave a margin. Details are in the key limits documentation↗.

The short daily version

1. New task: /clear.
2. Task unclear: Shift+Tab, plan.
3. In the request: file, symptom, how to check.
4. The agent runs tests itself.
5. I read git diff, commit.
6. Once a day I check spend in the dashboard.

FAQ

Should I always use plan mode?

No. For small edits that can be described in one sentence it only adds steps. Turn on planning for tasks spanning several files or in unfamiliar code.

How long should CLAUDE.md be?

Short. Every line is paid for in every session. Keep commands, structure and non-obvious conventions; the agent will read the rest from the code.

Can I leave Claude Code running unattended?

Only in an isolated environment and with a limit on the key. For autonomous work give the agent a check (tests) and a spend ceiling.

Which model should be the default?

It depends on your tasks. To start, take claude-sonnet-5-5 and move up to claude-opus-5-5 where the result did not satisfy you. Decide from your own examples.