The Big Deltas

Then vs Now

Native Binary

Claude Code no longer needs Node.js.

• Single ~100MB binary: your TypeScript app bundled with the Bun runtime
• ~5ms startup (was ~50ms with V8). No npm, no version conflicts
• Auto-updates in the background on startup

# or migrate from npm:
$ claude install
$ npm uninstall -g @anthropic-ai/claude-code

Auto Mode

A middle ground between approving everything and YOLO mode.

• A background classifier reviews each action before execution
• Auto-approves safe ops (local edits, reads, dependency installs)
• Blocks risky ops (force push, prod deploys, curl | bash)

# or Shift+Tab to cycle:
# Ask → Auto Edits → Auto → Plan

Sonnet 4.6 or Opus 4.6 only, research-preview still.

/loop – Scheduled Tasks

Cron-like recurring tasks within Claude Code.

• PR review monitoring
• Deployment health checks
• Periodic code quality scans

Disable mid-session: CLAUDE_CODE_DISABLE_CRON=1

/effort – Reasoning Control

Tell Claude how hard to think about your request.

• low for quick fixes and simple questions
• medium for everyday coding tasks
• high for architecture decisions, moderate debugging
• max for ambitious large work, complex debugging
• auto let claude decide (default)

Effort set to high ●
Extended thinking enabled for complex tasks.

Replaces the old ultrathink hack.

Voice Mode

• Hold Space to speak, release to send
• 20 languages, good transcription for dev terms
• Great for dictating requirements or pair programming

Voice mode active. Hold Space to speak.

Custom Agents

Define specialised agents in .claude/agents/

---
model: sonnet
effort: high
tools: [bash, read, write, Task(subagent)]
---

You are a senior test engineer. Your job is to:
- Write comprehensive unit & integration tests
- Ensure edge cases and error paths are covered
- Run `go test ./...` after every change
- Never modify production code, only test files

Invoke with claude --agent test-engineer

Hooks

Event-driven automation in your workflow.

• PreToolUse / PostToolUse for lint and format
• SessionStart to prime context

"PostToolUse": [{
  "matcher": "Write",
  "command": "npx prettier --write $TOOL_INPUT_FILE"
}]

Also: TaskCompleted, TeammateIdle, HTTP hooks

Skills

Reusable instruction sets you invoke as slash commands.

• Define in .claude/skills/ with a SKILL.md file
• Invoke manually (/skill-name) or auto-triggered by context
• Can restrict tools, set effort, run in isolated subagents

---
name: fix-issue
description: Fix a GitHub issue by number
user-invocable: true
argument-hint: [issue-number]
---

1. Read the issue with `gh issue view $ARGUMENTS`
2. Reproduce the bug with a failing test
3. Fix the code, ensure tests pass
4. Commit with "fix: closes #$ARGUMENTS"

Usage: /fix-issue 42

Skills Worth Adding

# Official Anthropic skills (commit, review, batch, etc.)
> /plugin install anthropic-skills
   github.com/anthropics/skills

# Design skills for UI/UX work
   typeui.sh/design-skills

# Cross-CLI skills (work with Claude Code, Gemini CLI, etc.)
   github.com/alirezarezvani/claude-skills

# Exhaustive community list
   github.com/VoltAgent/awesome-agent-skills

Plugins

Bundles of skills, agents, hooks, and MCP servers you can share.

• Install from marketplaces: /plugin install github@official
• Scoped to user, project, or org
• Admins can force-enable or restrict plugins for teams

Installed commit-commands (3 skills, 1 hook)
  /commit, /pr, /changelog

Skills are the instructions. Plugins are how you distribute them.

Plugins Worth Installing

# Symbol-level code understanding (30+ languages)
> /plugin install serena

# Persistent cross-session memory (github.com/thedotmack/claude-mem)
> /plugin marketplace add thedotmack/claude-mem
> /plugin install claude-mem

# Live, version-specific docs in your prompts
> /plugin install context7

# Browser control for frontend testing
> /plugin install playwright

/btw – Side Questions

Ask a quick question without derailing your main task.

• Ephemeral: doesn't pollute your conversation history
• Uses prompt cache, so it's cheap and fast
• Perfect for "what does this flag do?" mid-task

/compact – Context Compaction

Summarise your conversation to free up context space.

• Server-side summarisation, preserves coherence
• Run it before long tasks to maximise usable context
• Pass a topic to focus the summary

/review – PR Review

Get a detailed code review of a pull request.

• Analyses diffs, flags issues, suggests improvements
• Works with GitHub PRs out of the box
• Can post comments directly to the PR

/simplify – Code Cleanup

Review your recent changes for quality, then fix them.

• Checks for duplication, dead code, unnecessary complexity
• Applies fixes automatically after review
• Great to run before committing

Reviewing 4 changed files for reuse & quality...

/batch – Parallel Changes

Plan large-scale changes, then execute across isolated worktrees.

• Spins up 5-30 agents in parallel, each in its own worktree
• Research and plan phase first, then execute
• Creates a PR when done

Git Worktrees, Quick Primer

A worktree is a second working copy of your repo, on a different branch, sharing the same .git history.

• Unlike branches: no stashing, no switching. Both exist on disk simultaneously
• Unlike clones: no extra fetch, shared objects, lightweight
• Claude uses these to isolate agent work from your code

# two directories, same repo, different branches
# claude -w does this for you automatically

--worktree – Branch Isolation

Start Claude in an isolated git worktree.

• Changes happen on a separate branch, your working tree stays clean
• Ideal for exploratory work or multi-agent setups
• Worktree is cleaned up automatically if no changes are made

Complementary Tools

Claude Code handles the AI work. These handle everything around it.

# Navigate & merge worktrees without raw git commands
$ cargo install worktrunk          # github.com/max-sixty/worktrunk

# Auto-activate correct tool versions per worktree
$ curl https://mise.run | sh       # github.com/jdx/mise

# Track token usage and costs across sessions
$ bunx ccusage                     # github.com/ryoppippi/ccusage

# Native macOS terminal for managing AI agent sessions
$ brew tap manaflow-ai/cmux && brew install --cask cmux
                                     # github.com/manaflow-ai/cmux

# Watch agent teams work across panes (or use cmux above)
$ tmux                             # built-in to most systems

Memory in Claude Code

Claude has several layers of memory. Each serves a different purpose.

• CLAUDE.md – you write it. Instructions, conventions, project context. Loaded every session
• Auto-memory – Claude writes it. Patterns, preferences, learnings. Stored in ~/.claude/projects/<project>/memory/
• Session history – ephemeral. Gone when the session ends (use /compact to reclaim space)

Built-in auto-memory is local-only and capped at 200 lines in the index. For heavier needs, Serena adds symbol-level code memory and Claude-Mem adds persistent cross-session recall with compression.

/memory – Persistent Memory

Claude remembers things across sessions automatically.

• Records your preferences, project context, feedback
• Recalled in future sessions without you asking
• View and edit with /memory

3 memories stored:
  user_role.md - senior Go engineer
  feedback_testing.md - always use table-driven tests
  project_auth.md - auth rewrite for compliance

/fork – Branch Conversations

Copy your conversation to try a different approach.

• Original conversation stays untouched
• Explore alternatives without losing your progress
• Both branches are independently resumable

Forked session. Original preserved as "auth-refactor".

/rewind – Undo Everything

Roll back conversation and code changes together.

• Reverts both the conversation state and file changes
• Pick how far back to go
• Use when Claude goes off track

Select a checkpoint to rewind to:
  [1] Before "refactor auth middleware"
  [2] Before "add error handling"

/rename – Named Sessions

Give your sessions meaningful names for easy lookup.

• Auto-generate a name from context, or set one yourself
• Start with a name: claude -n "auth-refactor"
• Resume later: claude --resume auth-refactor

Session renamed to "api-v2-migration"

--bare – Scripted Mode

Minimal Claude for CI/CD pipelines and scripts.

• Skips hooks, LSP, plugins, auto-memory
• Combine with -p for non-interactive use
• Fast startup, predictable output

--from-pr – PR Context

Start a session with full context from a GitHub PR.

• Loads the diff, description, and comments automatically
• Great for reviewing or continuing work on a PR
• Pairs well with --resume for ongoing PR work

How It Works

When to Use (and Not)

• Parallel feature work on independent modules
• Competing hypotheses: debug by debate
• Cross-layer coordination: frontend + backend + tests

• Same-file edits: agents will conflict
• Sequential dependencies: too much overhead
• Simple tasks: single session is faster and cheaper

Reducing Hallucinations

Claude can still make things up. These patterns help keep it honest.

• Let it say "I don't know" – give explicit permission to admit uncertainty
• Ground with direct quotes – ask Claude to extract exact quotes before analysing
• Verify with citations – require a supporting quote for each claim, retract if none found
• Restrict to provided context – "only use information from these documents"

When answering questions about this codebase:
- Only reference files you have actually read
- If unsure, say "I'm not sure" rather than guessing
- Back up claims with exact code snippets
- Do not invent function names, APIs, or config options

Resources

• Docs: code.claude.com/docs
• Agent Teams: code.claude.com/docs/en/agent-teams
• Changelog: code.claude.com/docs/en/changelog
• Anthropic Academy: 13 free courses incl. "Claude Code in Action"
• Usage tracking: ryoppippi/ccusage
• This deck: thushan/talk-claude-code