Summaries > AI > Claude Code > What Claude Code Can Do That You Haven't Tried - Gui Ferreira - NDC Oslo 2026...

What Claude Code Can Do That You Haven't Tried Gui Ferreira Ndc Oslo 2026

https://www.youtube.com/watch?v=P3TCZ2xrvbo

TLDR Claude Code becomes far more useful when you keep its setup and context lean, clarify plans before implementation, and use features like hooks, skills, worktrees, and automation to handle repetitive work. The same workflows can also organize personal files, notes, schedules, and other everyday tasks—not just write code.

Key Insights

Start with a lean, well-organized project setup

Run `/doctor` to check your Claude Code installation, then keep `CLAUDE.md` focused on instructions that apply to nearly every task. Move reusable procedures into skills, language- or file-specific guidance into `.claude/rules`, and personal preferences into `CLAUDE.local.md` or your user-level profile. Use `@` imports to reference existing documents instead of duplicating them. A lean setup is easier to maintain and can avoid the performance and cost problems associated with overly long instruction files.

Protect sensitive files and share project tools safely

Use `.claude/settings.json` to deny access to secrets, environment files, or commands that should not be used during troubleshooting. Keep team MCP server configuration in a committed `.mcp.json` so teammates can use and audit the same project tools. Use `/import` when bringing configuration, MCP servers, or subagents from another coding tool. These practices make the environment safer and more consistent across a team.

Clarify the goal before asking Claude to implement

For larger changes, enter plan mode with `Shift+Tab` and review the proposed approach before coding begins. Edit the plan directly with `Ctrl+G`, and ask Claude to interview you until key decisions and assumptions are clear. Use `/goal` to specify both the desired result and how to verify it, giving Claude concrete criteria for its work. This upfront clarification helps prevent rework and supports more reliable implementation.

Manage context and keep work sessions focused

Use `/context` to see what is taking up the context window, especially at the start of a fresh session. Run `/compact` when Claude begins looping or moving through repeated trial and error, and compact between major stages to preserve useful project knowledge without carrying every prior message forward. If you change direction, use double Escape or `/rewind` to revise an earlier prompt rather than layering discarded instructions onto the conversation. Use `/memory` to remove inaccurate or irrelevant memories and promote useful shared guidance into project documentation.

Choose the right controls for everyday work

Select a model with `/model` and adjust its reasoning effort to match the task; reserve maximum effort for prompts that genuinely need it. While Claude is busy, Ctrl+S lets you draft a prompt for later, and `/btw` lets you ask a side question without adding it to the main task’s context. Use `!` to run familiar shell commands directly, but remember that their output still consumes context and should not expose sensitive information. Check `/diff` to review changed files, and use a status line or `status` command to monitor session details and token costs.

Automate verification with hooks and reusable skills

Configure post-tool hooks to run tests and linters automatically after Claude completes work, then return failures to the conversation so Claude can fix them before finishing. This makes verification more dependable than relying only on written reminders. Treat skills as packaged capabilities that can include instructions, documentation, and scripts in any language. Before building a custom skill, consider built-in options such as `/patch` for large migrations, `/simplify` for maintainability improvements, and `/loop` for repeated checks.

Use parallel workflows and richer inputs where helpful

Git worktrees let you handle a feature, code review, and bug fix in parallel without mixing their working files. For front-end tasks, provide screenshots so Claude can use visual context alongside your prompt; on Mac, paste into the terminal with Control-V. Voice mode can help you reason through a problem by speaking it aloud, while `/rename` and `/color` make concurrent conversations easier to distinguish. Remote control and the agents view can also help you delegate work and monitor multiple running agents.

Extend Claude Code beyond software development

Claude Code can work with ordinary files and scripts as well as source code, making it useful for organizing downloads, summarizing meetings, preparing reviews, and finding upcoming tasks. You can connect Markdown-based notes, such as an Obsidian vault, to build repeatable workflows while keeping your files under your control. Headless mode with `claude --print` or `claude -p` lets scripts send input for analysis or transformation and pass the result into another process. Start with one useful personal or team workflow, then turn repeated steps into a skill.

Questions & Answers

How should you organize Claude Code instructions and configuration?

Keep the shared `CLAUDE.md` lean and focused on guidance needed for every task. Use `@` imports to reuse documents, skills for occasional procedures, and `.claude/rules` for language- or file-specific guidance. Put personal, Git-ignored preferences in `CLAUDE.local.md`, cross-session preferences in the user-level `.claude` profile, and team instructions in the shared `CLAUDE.md`. Use `/doctor` to check the installation and review documentation that may have drifted out of date.

How can you keep Claude Code secure and make its setup available to teammates?

Use project `.claude/settings.json` to deny access to sensitive files and commands. Store project MCP configuration in a committed `.mcp.json` so teammates can use and audit the project’s MCP tools, rather than relying on individual user profiles.

How can you plan larger changes and clarify requirements before implementation?

Use plan mode (`Shift+Tab`) to research and propose an approach, and edit the plan directly with `Ctrl+G`. Ask Claude to interview you and clarify decisions before implementation; the speaker suggests prompting it not to stop until the requirements are clear.

How can you manage Claude Code’s context window and recover when a task changes direction?

Use `/context` to see what is taking up the context window, avoid loading unnecessary information, and run `/compact` when Claude loops or between implementation stages. Use double Escape or `/rewind` to revise an earlier prompt instead of adding discarded instructions to the conversation. Audit `/memory` and remove inaccurate or irrelevant memories.

Which commands and controls help manage everyday Claude Code work?

Use `/model` to choose a model and set its reasoning effort; “ultra think” requests maximum effort for one prompt. Press `Ctrl+S` to stash a draft prompt, use `/btw` for a side question that does not enter the main task’s context, run familiar commands with `!`, and use `/diff` to inspect changes. The status line or `status` command can show costs and model usage.

How can Claude Code verify its own implementation?

Use `/goal` to specify what Claude should build and how to verify it. Post-tool hooks can run linters and tests automatically after a task, send failures back to Claude, and let it fix problems before declaring the work complete.

What built-in skills and features can help with common workflows?

Try `/patch` for parallelized large migrations, `/simplify` to reduce duplication and improve maintainability, and `/loop` to repeatedly check a condition such as deployment status. Skills can package prompts, documentation, and scripts in any language for reusable team workflows.

How can Claude Code be used for visual, parallel, or remote workflows?

For front-end work, paste or drag screenshots into the terminal; on Mac, use Control-V rather than Command-V. Git worktrees support parallel work on features, reviews, and bug fixes. Use `/color` and `/rename` to distinguish conversations, `/focus` to show the initial prompt and final result, and the agents view to monitor or switch between agents. Remote control can let you continue from your phone and handle approval requests or completion notifications.

How can Claude Code be used outside interactive coding sessions?

Run Claude in headless mode with `claude --print` or `claude -p` to analyze or transform input in scripts and pipelines. It can also help with everyday work such as summarizing project contributions, organizing files, summarizing meetings, finding to-dos, and working with Markdown notes.

What personal workflows did the speaker demonstrate?

The speaker described organizing a Downloads folder, preparing quarterly tasks, summarizing meetings, finding upcoming to-dos, and connecting notes in an Obsidian vault. They also synced Strava run history into Obsidian and used a weekly skill to plan training that accounted for a chronic disease.

What does the speaker recommend trying after the talk?

Try the `/insights` command and put two or three of the demonstrated ideas into practice.

Summary of Timestamps

The speaker opens by noting how quickly Claude Code is evolving, including its 104 default slash commands, and says users can become much more productive by learning just a handful. The session is a rapid-fire collection of practical ideas for people who have already tried Claude Code, with the goal of leaving attendees with two or three techniques to use right away. The speaker mostly works in the terminal, though many tips also apply to the editor and desktop versions.

Set up project instructions carefully. Use `/import` to bring configuration, MCP servers, and subagents from other coding tools into Claude Code. Keep `CLAUDE.md` lean: the speaker cites research suggesting long, descriptive instruction files can reduce performance and raise costs. Use `@` imports to reference existing documents, skills for occasional procedures, and `.claude/rules` for guidance that applies only to particular languages or files. Keep instructions only when they are needed across tasks and cannot be inferred.

Check and organize your Claude Code setup with `/doctor`, and periodically review project documentation so it does not drift out of date. Use `CLAUDE.local.md` for personal, Git-ignored preferences, shared `CLAUDE.md` for team guidance, and a user-level `.claude` profile for preferences that should apply across sessions. Project `.claude/settings.json` can deny access to sensitive files and commands. The speaker also recommends customizing the theme and status line to show useful details such as the project, branch, model, and context-window usage.

For substantial changes, use plan mode (`Shift+Tab`) to research and outline an approach before implementation. Edit the plan directly in your editor with `Ctrl+G` instead of repeatedly discussing minor changes, and ask Claude to clarify assumptions before it starts. One suggested prompt is: “Interview me and don’t stop until we clarify every single thing.” This brings important decisions forward, when they are easier to make.

Manage the conversation as work evolves. Use double Escape or `/rewind` to return to an earlier prompt when changing direction, rather than leaving discarded instructions in the context. Choose a model with `/model` and set its reasoning effort; “ultra think” can apply maximum effort to a single prompt. While Claude works, Ctrl+S saves a draft prompt for later, and `/btw` lets you ask a side question without interrupting the main task or adding it to that task’s context.

Monitor costs and context. The status line or `status` command can show token usage and which models were used, including by sub-agents. Use `/context`, especially at the start of a fresh session, to see what is taking up the context window. Keep it focused by avoiding unnecessary information and running `/compact` proactively when Claude begins looping or making repeated trial-and-error attempts; compacting between stages can preserve useful project knowledge without carrying the entire conversation forward.

Review Claude’s saved memories with `/memory` and remove anything inaccurate or irrelevant. Promote useful preferences and rules into `CLAUDE.md` when they should benefit the whole team. For familiar commands, use `!` to run them directly in Bash rather than spending Claude’s reasoning on them, while remembering that command output still enters the context. Use `/diff` to inspect changed files and lines, and consider remote control when you want to delegate work and continue from your phone or step away while receiving approval requests and completion notices.

Several interaction and parallel-work features can make everyday development smoother. `/voice` enables spoken discussion—hold the space bar to talk—and screenshots can be pasted or dragged into the terminal for front-end tasks; on Mac, use Control-V rather than Command-V. Git worktrees support parallel feature work, code review, and bug fixes. Use `/color` and `/rename` to distinguish conversations, `/goal` to define what to build and how to verify it, `/focus` to hide intermediate messages, and the agents view to monitor or switch among running agents.

The speaker introduces hooks as a way to get fast feedback when something goes wrong. Post-tool hooks can run linters and tests after Claude completes a task and feed failures back into the conversation so Claude can fix them before declaring the work finished. This can be more reliable and use fewer tokens than relying on written instructions alone, since running shell commands does not itself consume Claude’s reasoning tokens.

Think of skills as packaged capabilities rather than prompts alone: they can include scripts written in any language as well as documentation, making team workflows available on demand. Before building a custom skill, try the built-in `/patch` for large parallelized migrations, `/simplify` to reduce duplication and improve maintainability, or `/loop` to repeatedly check a process such as deployment status.

Keep project MCP configuration in a committed `.mcp.json` instead of installing every server in a personal profile or documenting setup elsewhere. A shared configuration makes the project’s MCP tools available to teammates and gives the team a clear way to audit which tools it uses. Claude Code can also run in headless mode with `claude --print` or `claude -p`, allowing scripts and pipelines to send it input, receive an analysis or transformation, and pass the result to another step.

Claude Code can support work beyond writing software. For a quarterly review, for example, it can summarize code-related contributions and projects, avoiding the need to reconstruct them from old emails and calendar events. The speaker frames Claude Code alongside Claude Cowork and claude.com, emphasizing that Claude Code is also a powerful tool for automating everyday tasks.

The speaker gives examples of working with ordinary files and reusable skills: organizing Downloads, preparing quarterly tasks, summarizing meetings, finding upcoming to-dos, and connecting notes in an Obsidian vault. Because the notes remain in the user’s control as Markdown files, they can be used with Claude Code, Cursor, or other tools. The speaker also syncs Strava history into Obsidian and uses a weekly skill to plan running that accounts for a chronic disease, helping make training safer and more consistent.

The talk closes with a recommendation to try `/insights` and an invitation to enjoy the conference. The broader takeaway is to start with a few practical features, keep project context organized, and use Claude Code for both development and everyday workflows.