What's the single most important Claude Code practice for a team?

Shared, owned context. A per-developer CLAUDE.md works when one person uses Claude Code, but it drifts the moment a team does — everyone ends up with a slightly different file and the agent gives inconsistent answers. Move the durable context (decisions, conventions, ownership) into one place every agent reads.

Where should project context live — CLAUDE.md or somewhere else?

Put stable, local instructions in CLAUDE.md (build commands, style rules, repo layout). Put cross-cutting, evolving knowledge — why a decision was made, who owns what, how domains relate — in a context tree the whole team reads. CLAUDE.md is per-repo config; the tree is shared memory.

How do I stop CLAUDE.md files from drifting across a team?

Keep CLAUDE.md minimal and treat the context tree as the source of truth for decisions. When the team standardizes on something, it's recorded once, in an owned node, under review — not copy-pasted into each person's local file.

Do these practices apply to subagents and hooks too?

Yes. Subagents and hooks are how you operationalize these practices — e.g. a SessionStart hook that loads shared context, or a subagent scoped to one domain with that domain's node in view.

Claude Code Best Practices for Teams

Claude Code is excellent out of the box for a single developer. The practices below are about the harder case: keeping it consistent, fast, and trustworthy when a team uses it across the same repos. The throughline is simple — solo habits don't survive contact with a team, so the practices that matter most are the ones that make context shared.

Start with a tight CLAUDE.md

Your CLAUDE.md is the first thing the agent reads. Keep it short and stable: build and test commands, code style, repo layout, the handful of rules that are always true. Resist the urge to pour every decision into it — a long, churning CLAUDE.md is noise the agent has to wade through on every task, and it goes stale fast.

Commands first. How to install, build, test, lint. The agent should never guess these.
Conventions, not history. "Use 2-space indent" belongs here; "we switched off X in Q2 because…" does not.
Keep it under a screen. If it's longer, the durable parts probably belong in a shared context tree, not the per-repo file.

Scope permissions and tools deliberately

Decide up front what the agent may do without asking — and what it must confirm. Pre-approving safe, frequent commands removes friction; gating destructive ones (deletes, force-push, prod operations) keeps you safe. The goal is an agent that moves fast on the boring stuff and pauses on the dangerous stuff.

Use subagents for focus

For anything non-trivial, delegate to a subagent scoped to the task. A subagent with a narrow brief and the right context in view outperforms one giant session trying to hold the whole codebase at once. Treat subagents as specialists, not as a way to parallelize everything blindly.

Automate the repetitive parts with hooks

Hooks let you wire deterministic behavior into the agent's lifecycle — format on edit, block edits to protected paths, run a check after a tool call. The highest-value hook for a team is a SessionStart hook that loads your shared context so every session begins already knowing your team's conventions.

The practice that scales: shared, owned context

Here's where solo advice and team advice diverge. A single developer's CLAUDE.md captures their context perfectly. Five developers produce five drifting files, and the agent answers differently depending on whose machine it's on. The fix isn't a bigger CLAUDE.md — it's moving the durable knowledge somewhere shared, owned, and versioned.

This is what First-Tree does.

First-Tree is an open-source orchestration platform for teams shipping with humans and Claude Code agents side by side: agents coordinate in shared threads, GitHub issues and PRs become the work queue the right agent picks up, and a context tree — a Git repo where decisions, conventions, and ownership live in Markdown nodes — gives every agent the same memory to read. One source of truth, under review, instead of N copy-pasted CLAUDE.md files. Wire the tree into Claude Code with a SessionStart hook and every agent — yours and your teammates' — starts from the same page.

Anti-patterns to avoid

The CLAUDE.md dumping ground. Every decision pasted in until no one reads it. Move history and rationale to a context tree.
Per-developer context drift. Five people, five different CLAUDE.md files, inconsistent agent behavior. Centralize the durable parts.
Undocumented decisions. A choice made in a session that no future agent can see. If it matters, it belongs in an owned node.
One mega-session. Trying to do everything in a single context window instead of delegating to scoped subagents.

If your team is running Claude Code across several repos and people, the shared-context problem is the whole game — it's exactly what the AI agent teams approach addresses, and Claude Code for teams walks through the setup end to end.