What Claude Code Can Do That You Haven't Tried

1. Forty things, four buckets 0:11

Gui Ferreira opens with a number that does the work of a whole slide: Claude Code had 104 slash commands available by default on the Friday before the talk 0:49. He is not affiliated with Anthropic — the framing throughout is "someone who uses the tool every day and feels it is helping him a lot" — and that matters, because the talk is not a feature tour of everything available. It is a list of what survives in one person's actual week.

The diagnosis he keeps coming back to: people install Claude Code, ask it to build something, watch it write tests and reviews and find bugs in a couple of minutes, and then learn 10–20% of the tool. The rest of the talk is an attempt to push that number up by showing the edges — the parts that only become visible once you stop treating the agent as autocomplete.

He also says where you run it changes what you get: terminal, editor extension, and the desktop app all work, but experimental features tend to land in the terminal first 3:47. That is his reason for living in the terminal, and it is a practical reason to treat the rest of the talk as terminal-first.

2. /import and the file-format mess 4:22

The first move is for the person who tried Codex or Cursor, drifted away, and now wants their muscle memory back. /import takes the name of the product and pulls the configuration across — MCP server config, subagent definitions, the lot — instead of you rebuilding it by hand. The official command reference documents the accepted sources as /import [codex|gemini|cursor], with --dry-run and --yes flags, so you can see what it would move before it moves it.

The reason the command has to exist is the thing Ferreira spends the next minute attacking: coding agents do not share a standard for where their instruction files live. Everyone puts them in different folders, and — worst of all — under different names for the same concept. The instruction file you know as CLAUDE.md is AGENTS.md elsewhere. That file, he argues, is one of the most important artifacts in a project, and the industry has built misconceptions around it.

The specific failure he names is duplication: the same information migrating into the README, then into CLAUDE.md, until the agent absorbs all of it and becomes confused — it tries one path, it doesn't work, it needs to go through another. His counter-move inside the file itself is the import directive: write @path/to/file and Claude Code pulls that file in, so a team-rules document or an API schema lives in exactly one place and is referenced rather than copied.

3. CLAUDE.md: what ETH Zurich actually measured 5:48

His evidence is a study he attributes to ETH Zurich, run across agents that use CLAUDE.md-style files and AGENTS.md-style files, with three populations: groups hand-crafting the context file, groups generating it with a model, and groups with no context file at all. The headline he quotes — a 3% drop in performance and a 20% increase in cost for a long, descriptive context file — is accurate as a summary, and the paper behind it is real: Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents? (arXiv:2602.11988).

On the numbers, the talk is right and conservative: the paper's own abstract says context files "tend to reduce task success rates compared to providing no repository context, while also increasing inference cost by over 20%." The nuance worth adding is the middle row — hand-written files were the one condition that helped, by a small margin, while still paying the cost premium. The paper's recommendation follows from that: omit model-generated context files, and keep only minimal requirements a human actually wrote.

The three questions

Ferreira turns that finding into a per-line audit of his own CLAUDE.md:

The last question is the sharpest, because it has a failure mode attached: the agent can discover the layout itself, and a hand-written map drifts from reality the moment someone moves a file — so a fact that was merely redundant becomes actively wrong. Rules that are specific to a language or file extension belong in .claude/rules/ as separate files; the reference docs confirm .claude/rules/*.md are loaded as instruction files, and there is even an InstructionsLoaded hook that fires when they or a CLAUDE.md enter context.

4. Three layers of instructions + a permission deny list 9:25

Most people treat CLAUDE.md as one file in one place. Ferreira counts three layers, each with a different audience.

All three are documented behaviour, and the global layer is the one people forget exists: preferences that are about you rather than about the codebase belong there, so you stop re-pasting them.

The part he makes you promise to do

The second half of this section is not a feature but a failure story: a database connection bug that happens "only once in a while," Claude read-tries-and-retries, reads your secrets, your settings, your environment variables — and it will keep doing that unless you deny it. His aside kills the standard objection in advance: "no one puts production keys in the settings file" is true of you and false of the teammate who will do it one day when it's actually needed — and in that moment the keys go over the wire.

The fix is small and permanent: in settings.json, add a permissions.deny list of file extensions and bash commands you never want executed or read. He describes it as a small thing to do that is quite important; the general permission-rule machinery in the docs is the same system that powers allow/deny patterns for tools.

5. The status line as a dashboard 12:04

Themes get a mention (you can now theme the agent itself, not only the terminal — accepting the embarrassment of two themes to keep in sync), but the item he actually insists on is the status line. He describes it as a dashboard over the current session, and the fields he wants in it are the ones you cannot reconstruct from memory after ten minutes of work:

• which project / working directory you are in,
• the git branch,
• the model currently in use,
• the percentage of the context window consumed.

Creating it is a conversation, not a config file: run /statusline and describe what you want; Claude writes the script that renders it. The docs match — /statusline configures it, and running it with no arguments auto-configures from your shell prompt. The reason this ranks above themes for him is that it makes the next three sections legible: you can only notice that your model or effort level is wrong if you can see it.

6. Plan mode, Ctrl+G, and "interview me" 13:58

Plan mode is the entry point: cycle the mode with Shift+Tab, and Claude researches the change instead of making it. The interesting part is what happens when the plan comes back *almost* right — one line wrong, something you could have written yourself. Ferreira's confession is that he used to argue in chat, refining a proposal one sentence at a time, which he calls not that productive.

The alternative is one keystroke: Ctrl+G opens the plan as a Markdown file in your editor. You edit the file, save, and Claude picks up your changes and continues. He calls it "like a shared Google Doc with Claude." The keybindings reference documents this as chat:externalEditor — open in external editor — so it is not a Claude-specific trick but the standard escape hatch into your own tooling.

The second half of this section is about a subtler failure: plans arrive full of assumptions you never discussed, because the model wants to be productive and your prompt was not descriptive enough. His fix borrows the mechanism Claude already uses when it asks "option A or option B?" — the ask-user-question tool — and points it at the plan:

What he reports is that things were not as clear as he thought, and that being interviewed moves the decision to before the code exists instead of after. This is the cheapest high-yield habit in the talk: it costs one sentence and converts a set of silent assumptions into an explicit list.

7. Rewind instead of argument 16:51

The scenario: you took the model's recommendation (MVC over minimal APIs), you started implementing, you looked at the code, and you don't like it. The normal move is to ask for a refactor back to the other design — and Ferreira names the cost precisely: every past direction and all the generated code stays in the context window, and once the window is big enough that history works against the next iterations.

His alternative is rewind: double Escape, or /rewind. Navigate to the message where the wrong decision was made, adjust the prompt there, and continue from that point — "one step back to take two steps forward." The docs describe /rewind as rolling code and conversation back to a checkpoint (or summarising part of the conversation), which is a bigger deal than undo: the wrong branch disappears from context rather than being argued with.

8. Model, effort, and the rainbow word 18:38

Everyone repeats "use a strong model to plan and a cheap one to execute." Ferreira accepts it and then points at the layer most people ignore: /model only picks which model; inside each model there are effort levels, and the level is where the tokens actually go. His concrete pairing — plan with Opus, implement with Opus at low effort — is a more precise version of the usual advice, and it is documented: /effort is a command, and the CLI flag accepts low, medium, high, xhigh, max, and ultracode, with availability depending on the model.

The problem with setting effort per conversation is that you forget you set it — his words, "at least I do" — so you end up debugging something hard at low effort. Hence ultrathink: type it in the prompt and that single turn runs at raised effort, then the session falls back to its own setting. He also admits the honest reason to try it: the word renders in rainbow colours, which is a nice animation.

Which turns the status line from a nicety into infrastructure: the model and effort you are actually running on are invisible without it, and both change per thread.

9. Stash, /btw, cost, and measuring an empty session 20:22

Four small moves for the minutes when the agent is already working.

Ctrl+S stashes the prompt you were writing

You are composing the next prompt while the current one runs; Claude stops mid-task to ask a question; you need both. The old hack was a notepad. Ctrl+S stashes the draft, you answer the question, bring the draft back and keep going. Documented as chat:stash in the keybindings reference.

/btw for the side question

If what you have is not the next prompt but a question ("did we discuss this aspect? are we using this pattern?"), writing it as a prompt means it queues behind the running turn. /btw runs it as an aside — answered while the main execution continues, and deliberately not added to the conversation history. The command reference describes it exactly that way: a side question that shouldn't add to the conversation history.

Cost, and which models you actually used

His argument about money is that infrastructure cost discipline has moved down a level: we used to argue about databases and cloud bills; now a CRUD endpoint has a token bill. The session status view tells you not only your most-used model but every model that participated — including the ones subagents brought in, which is how a "cheap" session turns expensive. The commands are /status for state and /usage (alias /cost) for spend; he also likes pinning cost into the status line, and jokes that at year end it makes a great screenshot for X.

/context in an empty session

This is the sharpest diagnostic in the talk: start a session, run /context before asking anything, and look at what is already consuming the window. Skills you downloaded because someone posted a top-ten list have a footprint each; configured MCP servers have a footprint; your context files have a footprint. If an empty session is at 8%, that is 8% of every future turn spent before you said hello, and the fix is maintenance rather than more purchases.

10. Compaction and the memories audit 25:22

Compaction normally happens at the end, automatically, when the window is full: Claude summarises history and replaces it so you can continue. Ferreira's argument is to do it before you are forced to, and the signal is behavioural: when the agent is visibly trial-and-erroring — trying a fix, failing, trying again, and you are mentally asking "are you stupid?" — that means something needs to leave the window. Be proactive: run /compact.

His own rhythm is structural rather than reactive: split an implementation into parts (data model, then domain model, then UI), and compact at each boundary instead of starting a fresh conversation, because the accumulated context of that phase took time to build and is worth keeping in summary form.

The Emily story

Then the best anecdote of the session. Ferreira noticed Claude kept addressing him as Emily. He had never asked to be called Emily. He opened the memories folder and found the origin: at some point he had asked Claude to parse and summarise a blog post, the post contained the sentence "my name is Emily," and the agent concluded that his name was Emily 27:07.

Two lessons, and he draws both. Memories are autoloaded across applications, so they can capture things you did not imagine. And the audit is not only about deleting junk: run /memory, walk the folder, and look for preferences Claude spotted about you that you never generalised — a way you always want things done. Those get promoted into CLAUDE.md, which turns one person's memory into a rule the whole team benefits from.

11. !, /diff, and remote control 28:26

Three items, in increasing order of how much they change your day.

Prefix with ! and stop paying for reasoning

For commands you already know how to run — ls, npm test, npm run — prefix the line with ! and everything after it runs as a bash command. No "what is this thing, how do I run that" turn. The caveat is one line long and important: the output does come back into the context window, so don't do it for anything that prints secrets.

/diff as a side pane

He used to keep a second terminal open for this; now /diff opens a pane showing the files being changed, per-line, and you can click into each. The docs note it opens the earlier diff viewer outside fullscreen rendering — which explains why some people see it differently depending on their rendering mode.

Remote control

The item that "changed the way I work, and my lifestyle," and he tells it as a story: a deliverable due the next day, a father asking to be picked up from a hospital appointment, and rather than choosing, he starts a long implementation, takes his phone, and keeps working from the Claude app while waiting 30:16. The laughter in the room is because it is a work-life-balance joke; the second example is the one that pays for itself — start a two-hour execution at your desk, go for a walk, and get push notifications when the agent needs approval or is done.

12. Voice and screenshots as first-class input 32:15

He pre-empts the objection: many of you won't agree with me, but I like this one. The argument comes from the pre-pandemic office — you would spend hours on a problem, walk to a colleague, start explaining, say "ignore it, I know what it is" mid-sentence, and fix it in minutes. Speaking changes how the brain works through a problem. Voice mode reproduces the colleague.

Mechanically: /voice enables voice dictation, then press and hold the space bar and talk — the prompt gets written for you. The command reference documents /voice [hold|tap|off], so the hold-to-talk behaviour is a mode you can choose; it also requires a Claude.ai account. His own caveat: don't do this in an open office.

Images are the other medium

For front-end work the multimodal path is more valuable than voice: screenshot a site or a Figma frame you like, paste or drag it into the terminal, explain what you want, and the model uses the image as the visual reference. On macOS the paste shortcut is Ctrl+V, not Cmd+V — which is documented (chat:imagePaste, with Alt+V on Windows/WSL) and is exactly the kind of detail that makes people conclude a feature doesn't exist.

13. Worktrees, /goal, /focus, and the agents view 34:33

The premise: in 2026 you spend a lot of time waiting for code to be written, so you work in parallel — and the naive version collapses, because everything happens on one branch in one working copy.

Git worktrees + visual identity

Worktrees are older than Claude Code: virtual folders inside your repo that let you build a feature, do a code review and fix a bug on the same project at the same time. The new problem is knowing which window is which. His solution is /color plus /rename: red for the bug fix, orange for the refactor, blue for the new feature, and the conversation renamed after the GitHub issue number. The docs list exactly those colour names, and note the colour syncs to claude.ai/code when Remote Control is connected.

/goal: define the stopping condition, then stop babysitting

Instead of a prompt, write a goal — not just what to build but how to verify it was built. His example: an invoice generator API, plus a test that calls the API and then a second call that produces a PDF which must look a certain way. Claude iterates as a loop until the verification passes, then comes back for feedback. The command reference describes /goal [condition|clear] as keeping Claude working across turns until the condition is met (or a model judges it impossible, or an error you have to fix clears it).

This is the difference between a long prompt and a closed loop, and it is the item that makes running several projects in parallel sane.

/focus and the agents view

Once you have five, six, seven things running, the logs are noise — very few of them need you. /focus shows only your last prompt, a one-line tool-call summary with diffstats, and the final response, so returning to a conversation tells you what you asked and what you got. And for many agents at once, either the desktop app or the agents view in the terminal: a single screen showing who is running, who needs attention, who finished, with jump-in navigation.

14. Hooks, skills, bundled skills, and headless mode 39:41

The platform layer is where behaviour stops being a suggestion.

Hooks: the deterministic version of "always run the tests"

Ferreira came to hooks through test-driven development, where the point is feedback as soon as possible. The comparison he makes is exact and it is the argument for hooks in one line:

The mechanism he describes is a post-tool-use hook that runs the linter and the tests, with the output fed back as information the agent can act on. The hooks reference documents PostToolUse and its decision controls, so this is mainstream, not a hack.

Skills are packages, not prompts

His correction to the common mental model: people think a skill is a prompt in a file that you call occasionally. He argues a skill is closer to packaging a small capability in a folder — SKILL.md is only the entry point, and next to it you can put the Python or PowerShell scripts it needs plus the Markdown explaining how to use them. His concrete case: your team has a Confluence page with scripts you run once in a while to fix a given problem. Package them as a skill and next time you just ask. Whatever language it is, if it runs on your machine, the skill can carry it.

Stop writing the skills Anthropic already shipped

His point is comparative: we spend a lot of energy shopping for code-review and refactor skills when the vendor ships the ones it uses to build the product. Try those first.

MCP servers belong to the project

The default behaviour is to install every MCP server into your user profile, where it applies everywhere and nobody can audit it. His rule: create a .mcp.json in the project, describe the servers there, commit it — so the next teammate who opens the project gets them automatically, and the list is reviewable in diffs. This replaces the README instruction that says "please install these MCPs."

Headless mode: claude -p

The last item of the platform section is the one that turns Claude Code into a component: claude -p "prompt" (or --print) runs the prompt, prints the answer and exits, with no interactive session. That means your shell scripts, PowerShell scripts and pipelines can have reasoning in them — pipe something in, let Claude analyse it, pipe the result somewhere else, all on your existing subscription.

15. Beyond code: reviews, Downloads, Obsidian, Strava 46:27

The final bucket is the one he cares about most, and it starts with a distinction: there are now three products — Claude Code, Cowork (a friendlier hybrid with access to the same things on your machine) and claude.com. As developers we don't need friendly; the point is that the same agent can operate on your own files.

Quarterly reviews

The recurring chore of being employed: the review meeting where you must recall what you did this quarter. Reconstructing it from email and calendar after four or six months is miserable. But if the work happened through Claude Code, it can tell you what you've been building — and then you turn that into a skill in your user profile and run it every quarter, instead of re-researching your own history.

The Downloads folder, 1,626 items

His version of the universal problem: nothing leaves Downloads until the disk complains. He was afraid of deleting something that mattered, even while knowing nothing of value was in there. So instead of deciding per item, he asked Claude to organise the 1,626 items into folders (folders included, so effectively more). With a handful of categories the decisions become trivial — code goes to GitHub, screenshots are disposable, installers are disposable — and only documents deserve a real look. He frames it as the general lesson: things that used to mean writing a Python script now take a couple of minutes.

Obsidian as the substrate

After trying OneNote, Evernote, Apple Notes, Notion, he settled on Obsidian because it is markdown files on his machine — "a client on top of a folder of markdown." The insight is a compatibility argument: Obsidian loves markdown, Claude Code loves markdown, so both operate on the same folder. In practice Claude Code surfaces what is due next month, summarises a meeting, shows where he is running late, and creates connections between notes; and because the files are plain, the vault keeps working if he switches to Codex or Cursor tomorrow. The cherry on top, in his words, is that you can run code inside Obsidian and get mermaid diagrams for slides — pretty, and he cheerfully admits useless.

Two skills and a chronic disease

The closing story is the strongest argument for the whole talk. Told years ago that he couldn't run because of a chronic disease, he eventually started anyway and learned the real problem was not running but running unstably — 5 km one week, 20 the next, no structure, nobody advising. So he built two skills: one that goes to Strava every day and pulls his runs into the Obsidian vault (all of his history, every year), and one he runs weekly that asks for the next week's plan while guaranteeing he doesn't return to the pattern that made him stop. He is healthier because of "just two skills and a set of files on my own machine" 52:00.

He ends with a challenge rather than a feature: if you learned nothing today, promise that next week you'll run /insights, which generates an HTML report analysing your recent sessions — where you work, how you use Claude Code, where things go wrong, and which features to try 53:57. It is the same move as the whole talk: measure your own usage instead of guessing at it.

16. Claims checked

Every command, shortcut and flag named in this talk was checked against the official Claude Code documentation at code.claude.com/docs (commands, keybindings, cli-reference, model-config, memory, hooks, goal, statusline) on 28 October 2026. The transcript was machine-generated and rendered "Claude Code" as cloth code, clod, quod and chachd, and "Codex" as codeex; names below are the corrected ones.

17. Key takeaways

• Your CLAUDE.md is probably too big, and there's evidence. LLM-generated context files measurably lower task success while raising cost over 20%; keep only minimal, human-written requirements.
• Delete anything the agent can discover itself. Folder maps, endpoint locations and layout descriptions go stale; a wrong map is worse than no map.
• Three instruction layers, three audiences. CLAUDE.local.md (gitignored) for personal habits, CLAUDE.md for the team, the user-profile file for preferences that follow you between projects.
• Deny secrets and risky commands in settings.json. Not because the model is hostile, but because a helpful agent will read anything plausible while chasing a bug.
• Rewind instead of re-prompting. If a direction was wrong, going back to the decision beats adding a correction on top of the wrong code still sitting in context.
• Effort is a second dial under the model. Plan and implement on different effort levels; use ultrathink for the one hard turn instead of raising the whole session.
• Measure an empty session with /context. What loads before you type anything is a permanent tax on every turn — skills and MCP servers included.
• Audit memories, then promote them. Agents capture accidental facts (hello, Emily); the useful ones deserve to become team rules in CLAUDE.md.
• Hooks beat instructions whenever you need a guarantee. A PostToolUse linter/test run is deterministic and free in tokens; "always run the tests" in a Markdown file is a hope.
• Write goals, not prompts, when you want to walk away. A verification condition turns one long turn into a loop that ends by itself.
• The highest-value uses have nothing to do with code. Quarterly reviews, a messy Downloads folder, an Obsidian vault, a weekly running plan: skills over the files you already own.
• Close with measurement. /insights generates a report on your own sessions — the same "look at the empty window" discipline applied to your habits.

18. Resources & links

• Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents? — the ETH Zurich study behind the CLAUDE.md section
• Commands reference — every slash command named in the talk, including /import, /btw, /focus, /color, /insights
• Keybindings reference — Ctrl+G, Ctrl+S, Ctrl+V, Escape/rewind
• CLI reference — claude -p, claude agents, --effort, claude import
• How Claude remembers your project — CLAUDE.md layers, CLAUDE.local.md, .claude/rules
• Models and effort levels — effort levels and the ultrathink keyword
• Keep Claude working toward a goal — /goal conditions and evaluation
• Automate with hooks — PostToolUse and decision control
• Customize the status line
• Terminal configuration — themes, voice dictation, image paste
• NDC Oslo — the conference where the talk was recorded

Basis note: built from the video's own transcript (YouTube captions, 1,301 timestamped lines) plus the vendor documentation above. Timestamps link into the video; the description carried no chapter list, so section boundaries follow the talk's own transitions.

19. Timestamp index