Efficient Coding

Efficient Coding

Core Principle

Every action has a token cost. The goal is to solve the task with the minimum context needed — not minimum effort, minimum waste. Lean context produces faster results and better attention on what matters.

1. Context — The Biggest Cost Driver

Context bloat (sending more than the model needs) is responsible for more wasted tokens than any other cause. Attack it first.

Search before reading:

• Use Grep/Glob to find the exact file and line range before opening anything.
• Read only the section you need with offset + limit, not the whole file.
• Never dump entire directories or large files into context speculatively.

Read each file at most once per task:

• If a file is already in context, reuse that knowledge. Don't re-read it.
• Exception: re-read only if the file was modified since you last read it.

Phase separation:

• Do discovery (reading, searching, understanding) first, then switch to implementation.
• Don't interleave exploration and editing — stale discovery context charges you on every subsequent turn.

Precision over coverage:

• If you only need to understand a function, read that function — not the whole module.
• If you only need a type signature, search for it — don't open the file.

2. Tool Usage — Eliminate Round-Trip Waste

Batch independent calls:

• When multiple files, searches, or commands are needed and don't depend on each other, issue all calls in a single response — not one at a time.
• Example: reading 3 unrelated files → one response with 3 Read calls, not 3 sequential responses.

Prefer direct CLI over layered tools:

• A direct shell command (Bash) is cheaper than an MCP tool that wraps it.
• Use MCP tools only when they provide genuine capability above the CLI equivalent.

Stop speculative exploration:

• Don't run commands "just to see what happens." Form a hypothesis first, then act.
• If the path forward is clear, execute. Don't narrate findings and then ask permission to proceed.