Claude Code

AI coding assistant by Anthropic. Operates as an agentic pair programmer with tool use, file editing, and long-horizon task execution.

Goals

Replace the slow loop of reading code → thinking → writing code → running tests with a faster loop where the agent does the mechanical parts: file search, reading, editing, running commands, interpreting output. The goal wasn't autocomplete — it was autonomous completion of multi-step engineering tasks.

Effectiveness

High, for well-scoped tasks. The Inertia Mill ports/adapters refactor, the podcast pipeline, the reviews site — all done through Claude Code, all substantially faster than solo. The agent handles the context-gathering and cross-file consistency that makes refactoring tedious. For open-ended tasks with clear acceptance criteria it's excellent.

What made it effective

• Tool use is the core differentiator. The agent reads files before editing, runs tests to verify changes, searches the codebase before proposing structure. It doesn't hallucinate file contents — it reads them.
• The memory system (MEMORY.md + topic files) lets the agent maintain context across sessions: secrets locations, SSH key preferences, architectural decisions, lessons learned. The agent builds on previous sessions rather than starting cold.
• Skills extend the base capability with domain-specific agents (inertia-mill, antfly, podcaster) installable as tools.
• Plan mode surfaces the approach before writing any code — useful for architectural decisions where the wrong approach is costly to undo.

Bonus utility

The agent notices things. Branding drift (inertia- instead of regular-), loose untracked files, expired patterns. The Jeeves dynamic — restoring order without being asked — has been more valuable than expected.

Friction / pain points / surprises

Context limits cause compaction, which loses nuance. Long sessions get summarised; the summary is accurate but lossy. Architectural reasoning from early in a session ("why we chose X over Y") can disappear. The memory system partially mitigates this but requires discipline to populate.

The agent sometimes over-engineers. Asked to fix a bug, it may refactor the surrounding code. Asked to add a feature, it may introduce abstraction for a single use case. Requires active steering: "just fix this, don't clean up the surrounding code."

Tool call latency accumulates. Each file read, grep, or bash invocation adds round-trip time. On tasks requiring many reads before any writes, the pace feels slow. Speculative parallel reads (reading 4 files at once) help but require the agent to anticipate what it needs.

Permission prompts interrupt flow. Every new type of action (new bash command, writing a new file path) requires approval. Reasonable as a safety model; friction in practice when doing exploratory work that touches many different commands.