당신이 몰랐던 클로드 코드 팁

Claude Code started as a terminal assistant. It's now an agentic system that reads entire codebases, executes commands, manages git workflows, and spawns subagents. If you're still using it as a chat interface with a shell wrapper bolted on, you're barely touching it. Features like CLAUDE.md  and MCP servers dominate the conversation. The CLI itself, though, has a deep set of power-user capabilities that mostly go ignored. These are features built for parallelised, production-grade engineering workflows. Here are 10 patterns worth knowing. 1. Context Pre-Warming via Session Forking Resuming a session across multiple terminals interleaves the history. That corrupts the context window in ways you won't notice until the model starts hallucinating about files that don't exist. -fork-session  solves this. It duplicates the full session lineage at that exact moment and produces a clean, completely independent branch. Think of it asÂgit branch  for your LLM context window. The workflow is "pre-warming." Load a master session with 40k+ tokens of architectural context, API documentation, and coding standards, then fork it for each new feature rather than rebuilding from scratch every time: # Build the heavy context session onceclaude"Read the architecture docs and prepare for feature work"/rename master-context# Fork it for specific tasks without polluting the originalclaude --resume master-context --fork-session This is also the right way to A/B test implementation strategies. Fork the same master session twice, let both branches diverge, and any differences in output are down to the approach, not context drift. 2. Seamless Code Review Loops Context switching during code review is one of the most underrated productivity killers in engineering. You wrote the code 3 days ago, the reviewer left comments this morning, and now you need to mentally reconstruct the entire decision space before you can say anything useful. If you created a pull request during a Claude session using gh pr create , the tool links the session ID to that PR automatically. When changes are requested, you rehydrate the exact state of the agent that wrote the code: claude --from-pr 447# orclaude --from-pr https://github.com/org/repo/pull/447 The agent resumes with the full conversation history of the original session: the files it read, the trade-offs it considered, the constraints it was working within For teams with multi-reviewer sign-off, this compresses the feedback loop from "context-switch, re-read, re-understand, respond" to "resume, address, push." 3. Compose Prompts in Your Editor The single-line REPL is hostile to complex prompt engineering. Pasting a 50-line stack trace, wrapping it in XML tags, and appending a multi-paragraph constraint inline is a fight against your own terminal. Ctrl+G  intercepts the input stream and opens your system's default $EDITOR  (Vim, Neovim, VS Code, whatever you've configured). You get macros, syntax highlighting, multiple cursors, snippet expansion, and proper multi-line editing. Compose the prompt, save and quit, and the full buffer flushes directly into Claude's execution loop. Prompt quality goes up noticeably when you can actually see and edit what you're writing. Small feature, outsized effect. 4. Execution via Inline Shell Prefix any input with !  and it bypasses the LLM entirely, executing the command directly in your shell. Useful on its own. What makes it powerful is what happens to the output: stdout  and stderr  are automatically appended to the LLM's context window. ! npm run test:e2e! git log --oneline -10 Run the command, output lands in context, then ask Claude to reason about it. No copy-pasting, no "here's the error I'm seeing" preamble. The model already has it. 5. Opus 4.6 Effort Levels Not every task warrants deep reasoning. Burning heavy compute on boilerplate generation is wasteful; using lightweight inference on a complex architectural decision produces poor results. Opus 4.6's Adaptive Thinking exposes a compute-scaling mechanism via the /model  command: an effort slider across 4 tiers (Low, Medium, High, Max). Low is fast, cheap, and essentially deterministic. Boilerplate generation, variable renaming, JSDoc comments. Max is high latency, high cost, deep reasoning chains: debugging race conditions, designing schemas for complex domains, resolving gnarly merge conflicts. For headless scripts, you can enforce this programmatically: export CLAUDE_CODE_EFFORT_LEVEL=lowclaude -p "Add JSDoc comments to src/utils.ts" Being intentional about compute allocation across hundreds of automated invocations adds up fast, both in cost and pipeline speed. This is the kind of feature that doesn't sound useful until you check your API bill. 6. Parallel Worktrees Running multiple Claude sessions against the same repository without isolation produces race conditions: agents trampling each other's file edits, creating impossible merge states. --worktree  uses nativeÂgit worktree Â