Most developers utilize only 5% to 10% of Claude Code's capabilities, missing out on dozens of built-in slash commands and advanced runtime controls after achieving modest initial gains. (0:06)
An ETH Zurich benchmark revealed that over-prescribed instruction files degrade output quality and inflate token costs by over 20%, proving that lean, human-curated context outperforms machine-generated instruction dumps. (4:42)
Exceeding 40% to 50% context window utilization pushes language models into a 'dumb zone' of diminished reasoning and degraded accuracy well before automatic compaction occurs at 99%. (27:26)
Replacing conversational verification with deterministic post-tool-use hooks in settings.json executes tests and builds outside the context window, eliminating token waste and catching syntax errors immediately. (42:31)
Detailed notes
## Background
Published on YouTube by NDC Conferences on July 1, 2026, this presentation was recorded live at the NDC AI conference in Oslo, Norway. In the talk, speaker Gui Ferreira draws from daily use and workshop instruction to demonstrate that most developers only utilize a tiny fraction of Claude Code, outlining permanent configurations, advanced terminal workflows, custom skills, and non-coding productivity use cases.
## TL;DR
Gui Ferreira delivers roughly 40 rapid-fire tips designed to elevate Claude Code from a basic autocomplete tool into an extensible development platform. He breaks down context optimization strategies—including the ETH Zurich findings that recommend keeping instruction files concise and human-curated—alongside granular security configurations in settings.json to block sensitive credentials. The session covers tactical terminal controls like context rewinds, non-blocking side queries with /btw, dynamic model switching, and avoiding context degradation in the 'dumb zone.' Finally, Ferreira showcases extensible automation through post-tool-use hooks, packaged agent skills, scoped MCP configurations, and creative non-coding applications like managing Obsidian note vaults and triage workflows.
## Atmosphere & style
The presentation is brisk, pragmatic, and delivered with the candid enthusiasm of a self-professed productivity addict. Ferreira balances dense, rapid-fire technical demonstrations with relatable humor about saving tokens, money, and sanity while wrestling with LLM quirks. The session feels like a generous, peer-to-peer terminal walkthrough rather than a polished corporate sales pitch, moving seamlessly from live configuration pitfalls to high-leverage power-user workflows.
## Bulletin
- [00:06](https://www.youtube.com/watch?v=zaDbZt40kRg&t=6s) Most developers utilize only 5% to 10% of Claude Code's capabilities, missing out on dozens of built-in slash commands and advanced runtime controls after achieving modest initial gains.
- [04:42](https://www.youtube.com/watch?v=zaDbZt40kRg&t=282s) An ETH Zurich benchmark revealed that over-prescribed instruction files degrade output quality and inflate token costs by over 20%, proving that lean, human-curated context outperforms machine-generated instruction dumps.
- [27:26](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1646s) Exceeding 40% to 50% context window utilization pushes language models into a 'dumb zone' of diminished reasoning and degraded accuracy well before automatic compaction occurs at 99%.
- [42:31](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2551s) Replacing conversational verification with deterministic post-tool-use hooks in settings.json executes tests and builds outside the context window, eliminating token waste and catching syntax errors immediately.
## Key takeaways
- [00:06](https://www.youtube.com/watch?v=zaDbZt40kRg&t=6s) Developers frequently fall into an adoption trap by treating Claude Code as a simple autocomplete tool rather than exploring its extensive suite of slash commands and autonomous features.
- [03:55](https://www.youtube.com/watch?v=zaDbZt40kRg&t=235s) New Claude Code features consistently debut in the terminal interface prior to appearing in IDE extensions or desktop wrappers.
- [08:20](https://www.youtube.com/watch?v=zaDbZt40kRg&t=500s) Root CLAUDE.md files should be aggressively pruned to include only rules relevant to 95% of tasks, offloading polyglot and scoped rules to .claude/rules or dedicated skills.
- [10:41](https://www.youtube.com/watch?v=zaDbZt40kRg&t=641s) Personal developer workflows like TDD should be kept in .claude/CLAUDE.local.md to avoid polluting shared team configurations, while global preferences belong in user home directories.
- [12:33](https://www.youtube.com/watch?v=zaDbZt40kRg&t=753s) Adding sensitive files and secrets commands to a permission_denied list in settings.json prevents accidental exfiltration during automatic error inspections.
- [16:21](https://www.youtube.com/watch?v=zaDbZt40kRg&t=981s) Pressing Ctrl+G in plan mode opens generated implementation plans directly as Markdown in an editor, eliminating conversational prompt cycles.
- [20:53](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1253s) Reversing prompt missteps using /rewind or double Escape preserves clean context, whereas corrective prompt chains inflate token costs and introduce noise.
- [21:53](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1313s) Developers can optimize costs and reasoning depth mid-session by pairing Opus for high-level architecture with Sonnet for code generation.
- [24:19](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1459s) The /btw command enables parallel side queries against context without interrupting or queueing behind active long-running tasks.
- [25:18](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1518s) Auditing empty sessions with /context exposes baseline token consumption (4% to 6%) caused by unneeded MCP tools and custom skills.
- [34:56](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2096s) Voice mode and image inputs allow developers to provide stream-of-consciousness explanations and visual references that ground front-end code generation.
- [37:52](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2272s) Parallel sessions isolated via Git worktrees and managed via 'claude agents' prevent branch collisions during autonomous multi-agent work.
- [43:52](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2632s) Packaging standalone scripts inside Agent Skills provides a lightweight alternative to maintaining full Model Context Protocol servers for simple tasks.
- [46:11](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2771s) Built-in Anthropic commands like /patch, /simplify, and /loop automate distributed multi-file refactoring, code deduplication, and periodic status polling.
- [48:48](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2928s) Confining MCP servers to project-level .mcp.json files prevents global context bloat across unrelated repositories.
- [52:05](https://www.youtube.com/watch?v=zaDbZt40kRg&t=3125s) Claude Code's headless CLI mode enables automated terminal pipeline scripting, log analysis, and local file organization beyond traditional software engineering.
- [55:37](https://www.youtube.com/watch?v=zaDbZt40kRg&t=3337s) Running the /insights command audits personal session logs to reveal operational bottlenecks and propose tailored productivity skills.
## Detailed walkthrough
### [00:06](https://www.youtube.com/watch?v=zaDbZt40kRg&t=6s) The 5% Trap: Why Most Developers Underuse Claude Code
Looking across a packed conference room, Gui Ferreira opens by probing whether developers actually understand Claude Code as well as they think they do. Curious about the true scale of the tool, he checked the previous evening to count its total features. While quantifying every capability proved difficult, he discovered that Claude Code currently boasts 96 distinct slash commands—adding with a chuckle that because the ecosystem moves so rapidly, Twitter might have revealed a 97th by morning.
Through running enterprise workshops over recent months teaching developers how to work with Anthropic's Claude Code, Ferreira observed a recurring behavioral pattern. Developers install the tool, immediately experience its raw power by generating routines, debugging issues, and fixing bugs, and then abruptly stop exploring further. Because the initial productivity boost feels so substantial, people naturally assume they have reached its limits. Ferreira argues that the vast majority of practitioners utilize merely 5% to 10% of what Claude Code can actually do, missing out on everything added since its earliest releases.
- **Available slash commands:** 96 at the time of the presentation (and climbing daily).
- **Adoption plateau:** Most developers stop exploring after unlocking an initial 5% to 10% productivity bump.
---
[01:48](https://www.youtube.com/watch?v=zaDbZt40kRg&t=108s) The Four Pillars and Ground Rules of the Session
To bridge this gap, Ferreira outlines an ambitious agenda structured into four distinct categories: permanent configuration habits you establish once and benefit from indefinitely; daily workflow enhancements that speed up repetitive development loops; techniques to make Claude extensible; and non-coding use cases that treat Claude Code as a versatile AI assistant rather than a glorified autocompletion engine.
Ferreira stresses that this session is strictly not a basic "getting started" tutorial for newcomers. It is tailored for developers who have already opened their terminal and run Claude Code at least once. He clarifies that he holds no formal affiliation with Anthropic and is not delivering a vendor sales pitch, but rather sharing field-tested problem-solving techniques from his own daily engineering practice. With roughly 40 rapid-fire tips scheduled across 60 minutes, the goal is not exhaustive depth for every feature, but exposing what is possible. As Gui Ferreira puts it, “if by the end of this session, tomorrow or next week, you can apply two or three of those 40, for me is a new success.”
---
[03:55](https://www.youtube.com/watch?v=zaDbZt40kRg&t=235s) Running Claude Code: Why the Terminal Comes First
Before diving into configuration, Ferreira tackles the runtime environment. Developers can interface with Claude Code across multiple surfaces, including IDE extensions such as VS Code, the modern desktop application, or directly within their terminal emulator of choice.
While all of these interfaces have their place, Ferreira reveals that almost all of his workshop slides and live examples showcase the terminal experience. His reasoning is straightforward: new platform capabilities and bleeding-edge updates consistently land in the command-line interface before trickling out to GUI wrappers or IDE integrations. As Gui Ferreira notes, “the terminal is where usually you get the features first.”
---
[04:42](https://www.youtube.com/watch?v=zaDbZt40kRg&t=282s) Mastering CLAUDE.md: Imports and the ETH Zurich Study
Ferreira introduces the project setup phase by focusing on the single most vital artifact in any Claude Code repository: the `CLAUDE.md` file (equivalent to `AGENTS.md` in other agentic ecosystems). Serving as the project agent's "heart and soul," it holds critical context regarding project architecture, framework constraints, and command guidelines. However, prolonged use frequently leads to documentation sprawl and duplicate text between `CLAUDE.md`, `README.md`, and pipeline documents. Ferreira explains that developers can completely eliminate this redundancy by using the `@` symbol to reference external files by path (for example, `@README.md` or `@api-schema.json`). When a Claude session boots, it automatically imports and ingests those referenced documents alongside the root file.
At the same time, Ferreira warns against over-stuffing this file. While he previously advised developers to dump every conceivable guideline into `CLAUDE.md`, recent empirical research has debunked that maximalist approach. He highlights an extensive benchmark study conducted at ETH Zurich that compared software repositories without `CLAUDE.md`, repositories with machine-generated files, and repositories with human-curated files. The researchers discovered that stuffing excessively specific and bloated instructions into the agent's context degrades overall output quality while driving token consumption up dramatically.
- **Import syntax:** Use `@<path-to-file>` inside `CLAUDE.md` to reference other Markdown files, API schemas, or relative file paths without copying text.
- **ETH Zurich findings:** Exhaustive, over-prescribed context files reduce task performance and increase token costs by more than 20%.
- **Human vs. Machine curation:** The study concluded that concise, human-maintained agent files consistently outperform automated, machine-generated instruction dumps.
> “So, someone took the the challenge of running a study at ETH Zurich.” — Gui Ferreira
---
[08:20](https://www.youtube.com/watch?v=zaDbZt40kRg&t=500s) Three Questions to Curate a Lean, High-Performance CLAUDE.md
In light of the ETH Zurich benchmark, Ferreira now applies a three-question pruning filter whenever he writes or audits a `CLAUDE.md` file, ensuring only high-leverage context survives:
```mermaid
flowchart TD
accTitle: CLAUDE.md Content Pruning Framework
accDescr: Three decision gates used to filter whether information belongs in CLAUDE.md, rules files, or should be omitted.
Q1{"Needed for 95% of tasks?"}
Q2{"Scoped to specific files/stacks?"}
Q3{"Can agent discover it alone?"}
KEEP["Keep in root CLAUDE.md"]
RULE["Move to.claude/rules or Skill"]
OMIT["Omit completely"]
1. **"Do I need this for every single type of thing?"** Evaluate whether the instruction is relevant to 95% of the conversations you will have in the repository. If an instruction only applies to rare edge cases, it should be removed from the root context.
2. **"Is it something specific that I only run once in a while?"** In polyglot codebases containing combinations of.NET, JavaScript, and Python, test execution commands and linting rules differ widely by directory. Rather than bloating `CLAUDE.md`, developers should extract these rules into dedicated Agent Skills or scoped Claude rules files located within the `.claude/` directory. By pairing these rule files with glob patterns, Claude loads them selectively only when the developer is touching those specific paths.
3. **"Is my agent capable of finding it alone?"** Developers frequently waste context documenting full folder hierarchies, noting where controllers, views, models, and infrastructure services live. Ferreira emphasizes that modern frontier models navigate disk trees with ease. Static folder maps quickly become outdated and confuse the model.
> “So, the recommendation from ETH Zurich is actually don't add those things that the agent can quickly find it.” — Gui Ferreira
[10:41](https://www.youtube.com/watch?v=zaDbZt40kRg&t=641s) Managing Personal and Global Preferences with CLAUDE.md
While a project root `CLAUDE.md` file serves as the shared standard for an entire engineering team, developers frequently run into situations where their personal working habits conflict with team consensus. For example, an engineer might be passionate about test-driven development (TDD), while other team members prefer not to use it. Attempting to force personal preferences onto colleagues by committing them directly into the shared `CLAUDE.md` creates friction.
To solve this, Claude Code supports multiple configuration layers. Inside the repository's `.claude` folder, developers can create a file named `CLAUDE.local.md` and add it to `.gitignore`. Claude Code automatically loads this local file alongside the project instructions, injecting individual preferences into the context window without imposing them on collaborators. Furthermore, if a developer wants preferences applied globally across every single repository and terminal session on their machine—such as enforcing concise language or formatting output strictly in bullet points—they can create a `CLAUDE.md` file within their user profile directory (located in `%APPDATA%` on Windows or `~/.claude` on macOS).
```mermaid
flowchart TD
accTitle: Claude Code Instruction Hierarchy
accDescr: Hierarchy showing how Claude Code loads configuration files from global machine settings down to local personal overrides.
subgraph Global["Machine-Level Configuration"]
A["Global User Profile (~/.claude/CLAUDE.md)<br/>Applies across every repo (e.g., concise tone, bullet points)"]
end
subgraph Project["Repository-Level Configuration"]
B["Shared Project Root (CLAUDE.md)<br/>Committed to git for team standards"]
C[".claude/CLAUDE.local.md<br/>Ignored by git for personal repo preferences (e.g., TDD)"]
end
A --> B
B --> C
```
As Gui Ferreira emphasizes regarding personalized setups:
> “Just write it there and it will applies in every single session that you have with Claude Code. Extremely useful for that type of scenario.”
[12:33](https://www.youtube.com/watch?v=zaDbZt40kRg&t=753s) Locking Down Secrets and Bash Commands via settings.json
Claude Code is designed to be relentlessly helpful; when given a task, it pursues the solution persistently until the goal is met. However, this helpfulness introduces major security risks when troubleshooting sensitive issues like database connectivity failures. When Claude encounters a database exception, it begins investigating the root cause and will instinctively inspect local configuration files—such as `.env`, `appsettings.json`, or environment settings—to verify connection strings. Once Claude reads these files, sensitive credentials, API keys, and connection strings are pulled straight into the context window and transmitted out to Anthropic's servers.
```mermaid
flowchart LR
accTitle: Claude Code Permission Deny Flow
accDescr: Diagram showing how settings.json blocks Claude from reading secret files and sending them to the API context window.
A["Claude Agent Task<br/>(e.g., Fix DB Bug)"] --> B{"settings.json<br/>Permission Deny Check"}
B -->|"Denied"| C["Blocked:.env, appsettings.json, user-secrets"]
B -->|"Allowed"| D["Context Window / Anthropic API"]
```
Because default tooling configurations do not automatically guard against this, teams must take proactive preventative steps immediately upon adopting Claude Code. By creating a `settings.json` file inside the `.claude` folder, teams can define strict `permission_denied` collections. This mechanism blocks Claude from reading specific configuration file types and restricts dangerous shell commands. Just like the instruction files, `settings.json` can be configured globally in the machine's user profile so that security protections persist across all projects.
Gui Ferreira highlights the danger of relying on default behaviors:
> “And the problem is that by default the tools don't lead you to take the best decisions in these cases.”
- **Sensitive file protection:** Explicitly deny file reads for `.env`, `appsettings.json`, and environment-specific credential stores.
- **CLI command restrictions:** Prevent the agent from executing shell commands that inspect secrets, such as `dotnet user-secrets` in.NET environments.
- **Global defense:** Apply security denies within the global user profile `settings.json` so forgotten repository-level configs do not expose production keys on local machines.
[15:06](https://www.youtube.com/watch?v=zaDbZt40kRg&t=906s) Monitoring Environment and Token Context with the Status Line
When running multiple terminal sessions and concurrently handling several branches or repositories, developers frequently lose track of their active working environment. To eliminate confusion, Claude Code provides a customizable status line displayed directly underneath the prompt input area.
The status line can be configured dynamically using natural language commands. Users can instruct Claude on what metadata to display, or simply ask Claude to list the available indicators. Essential status line metrics include:
- **Active Git branch:** Instantly reveals the current working branch across different terminals.
- **Active model:** Confirms whether Claude is running on Sonnet, Opus, or another model variation.
- **Context window consumption:** Displays the precise percentage of context used (for example, whether the session is at 2% or has climbed to 80%), warning users before context degradation or token compaction occurs.
[16:21](https://www.youtube.com/watch?v=zaDbZt40kRg&t=981s) Interactive Planning and Direct Markdown Editing with Ctrl+G
Many developers rely on plan mode to formulate an architectural approach before instructing Claude Code to modify files. However, an inefficient habit has emerged: when a developer reviews Claude’s proposed plan and notices one or two lines they disagree with, they often write another prompt to request revisions. This back-and-forth prompt cycle consumes excessive tokens, burns unnecessary time, and increases operational friction.
A much faster alternative is built directly into the plan mode interface. After toggling into plan mode using `Shift + Tab` and generating a strategy, developers can press `Ctrl + G`. This shortcut opens the generated plan directly as a Markdown document in edit mode inside the active editor (such as VS Code). The developer can navigate the file, refine or delete specific bullet points, save the changes, and return immediately to the terminal. Claude Code reads the modified document and proceeds with execution, keeping the workflow seamless.
As Gui Ferreira notes on refining plans:
> “You save time, you save tokens, you save your sanity as well.”
[18:30](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1110s) Specification-Driven Development and the AskUserQuestion Tool
In specification-driven development, the engineer drafts a specification document first, refines it, and then prompts the coding agent to implement the system. A recurring problem with this workflow is that developers rarely see the complete picture upfront, leading Claude to fill the informational gaps with unstated assumptions that only surface after code has already been written.
To prevent hidden assumptions, developers can take advantage of Claude's internal `AskUserQuestion` tool. While this tool typically triggers automatically during plan mode to present simple multiple-choice decisions (such as choosing between Approach A and Approach B), developers can deliberately prompt Claude to interrogate them exhaustively. By instructing Claude to run an interview loop—demanding it question every single assumption in the specification until full clarity is reached—developers discover critical edge cases and architectural trade-offs early.
For instance, Claude might clarify whether a service should be structured around traditional MVC controllers or lightweight patterns like ASP.NET Core minimal APIs and FastEndpoints. Uncovering these architectural divergences before writing implementation code prevents expensive rewrites downstream, where developers are otherwise forced to instruct Claude to scrap and convert an entire newly generated architecture into a different pattern.
Describing his approach to eliminating ambiguities, Gui Ferreira explains:
> “So, nowadays, I do the following. I ask Claude to interview me.”
[20:53](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1253s) Time Travel with Rewind: Stepping Back to Move Forward
When developers encounter a flawed implementation or an unwanted direction in Claude Code, the instinctive reaction is often to submit another message asking the tool to fix or modify what it just did. Gui Ferreira points out that this common habit actively degrades the conversation. Every corrective prompt simply stacks another message onto the ongoing context, dragging along all the prior research and failed code iterations. This historical baggage not only burns through valuable tokens on every subsequent call, but it also anchors and misguides future iterations because the model's past mistakes remain fully visible in its context window.
Rather than compounding errors by marching forward into context pollution, Claude Code offers an internal time-travel mechanism that operates much like a `git revert`. By either pressing double Escape or typing `/rewind`, users can step back through the interaction history, pinpoint the exact branching moment—such as choosing option A over option B—and re-prompt the model down a clean, alternative path. As Ferreira advises, “So, instead of trying to fix it by moving forward, give one step back to then go forward, okay?”
- **Context Pollution Impact**: Appending corrections keeps failed research and faulty implementations in memory, influencing subsequent outputs and inflating token usage.
- **Rewind Triggers**: Users can jump back to past conversation checkpoints using `/rewind` or by hitting double Escape (`Esc` `Esc`).
---
[21:53](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1313s) Strategic Planning, Dynamic Model Switching, and Effort Levels
Formulating an architectural or implementation plan is where the true heavy lifting takes place. Reasoning during the planning phase demands maximum model intelligence, making a flagship model essential. However, once Claude generates a detailed, robust roadmap, executing those step-by-step instructions no longer requires top-tier reasoning. Ferreira explains that running the execution phase on a cheaper, faster model saves both time and budget without sacrificing quality. Claude Code allows users to swap active models on the fly mid-stream—a change that is immediately visible if developers enable the terminal status line.
Beyond selecting between distinct models like Claude Opus and Claude Sonnet, Claude Code exposes fine-grained effort levels within each model via the `/effort` command. Raising the effort level tells the model to allocate deeper thinking time to complex problems, though it will consume more tokens and budget. When developers do not wish to alter the effort setting for the entire remainder of a session, they can target a single prompt using a quirky built-in trigger word: `ultra think`. Typing `ultra think` inside a prompt causes the command text to render as a rainbow in the terminal, signaling to Claude to expend whatever reasoning tokens are required specifically for that isolated task.
```mermaid
flowchart TD
accTitle: Two-Phase Strategy in Claude Code
accDescr: Flowchart illustrating heavy reasoning during planning with Opus followed by switching to Sonnet for cost-effective execution.
subgraph PlanPhase ["1. Planning Phase (Heavy Reasoning)"]
A["High-Reasoning Model<br/>(e.g., Claude Opus / High Effort)"] --> B["Detailed, Step-by-Step Plan"]
end
subgraph ExecPhase ["2. Execution Phase (Instruction Following)"]
B --> C["Switch Model / Adjust Effort<br/>(/effort or Cheaper Model)"]
C --> D["Fast, Low-Cost Code Generation"]
end
```
- **Dynamic Model Switching**: “So, actually, you can switch the model in the middle of a conversation.”
- **Global Effort Adjustment**: Running `/effort` sets the thinking intensity (from lower to extra-high) for all downstream prompts in that conversation.
- **Single-Prompt Effort**: Including `ultra think` directly in a prompt triggers maximum reasoning effort for that specific question and renders in rainbow colors.
---
[24:19](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1459s) Non-Blocking Queries: Running Parallel Prompts with /btw
A common source of developer friction occurs when Claude Code embarks on an autonomous multi-minute implementation journey. If a developer thinks of a contextual question while Claude is working, typing a standard prompt simply queues it behind the active task, forcing the developer to wait for completion before receiving an answer. Starting a completely fresh terminal session is equally unappealing because the new session lacks the active project and conversational context.
To eliminate this bottleneck, Claude Code provides the `/btw` (or `/by-the-way`) command. Entering `/btw` followed by a query spins up a parallel background inquiry against the existing conversation history. Claude answers the side question immediately without interrupting or pausing its primary execution workflow, allowing developers to inspect assumptions or clarify details without breaking their flow.
- **Queue Bypassing**: Normal prompts entered during execution wait in a sequential queue until the current run finishes.
- **Parallel Context Access**: `/btw` runs side queries concurrently against the existing context window without blocking ongoing tasks.
---
[25:18](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1518s) Inspecting Costs and Auditing Initial Context with /usage and /context
For developers tracking their operational expenses, Claude Code provides native financial and resource observability. Running `/usage` renders terminal graphics illustrating model consumption patterns, peak usage windows, and broken-down expenses for users on API key consumption tiers. Ferreira highlights that this terminal-native dashboard often surfaces richer, more immediate detail than Anthropic's web console—making it equally practical for routine auditing and bragging in end-of-year LinkedIn reviews.
Because cost directly mirrors context consumption, Ferreira urges developers to inspect what their sessions carry into memory using `/context`. While developers often notice their context meter when it reaches 60%, he challenges them to run an immediate experiment: open a brand-new, completely empty session and inspect `/context` before writing a single prompt. More often than not, users discover their baseline context is already consumed by 4% to 6% due to leftover Model Context Protocol (MCP) servers installed during past experiments or ancient custom skills that remain globally registered.
- **Terminal Cost Metrics**: The `/usage` command visualizes consumption patterns and API expenses directly in the command line.
- **Baseline Context Audit**: “Open a session with Claude. An empty one, okay? Just a new one, and run /context, and see what is there.”
- **Hidden Context Eaters**: Unused MCP servers and forgotten agent skills load by default into every fresh session, silently eating up window space.
---
[27:26](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1646s) Escaping the "Dumb Zone" with /compact and /clear
While flagship models boast vast context limits—such as Opus offering up to 1 million tokens—pushing a model toward its ceiling degrades performance. Ferreira references observations popularized by Dexter Horthy from HumanLayer regarding the phenomenon known as the "dumb zone." Once an active session crosses roughly 40% to 50% of its available context window, developers routinely experience noticeable degradation in answer accuracy, grounding, and response velocity.
```mermaid
flowchart TD
accTitle: Managing Context Degradation and Compaction
accDescr: Decision flow showing how to handle context usage crossing into the dumb zone.
A["Session Context Window"] --> B{"Usage Level?"}
B -->|"< 40-50%"| C["Optimal Quality Zone"]
B -->|"> 50%"| D["The 'Dumb Zone'<br/>(Lower Accuracy, Slower Speed)"]
D --> E{"Developer Action"}
E -->|"Preserve Core Context"| F["Run /compact<br/>(Summarizes context to ~15-20%)"]
E -->|"Start Fresh Workstream"| G["Run /clear<br/>(Wipes context completely)"]
```
When a session reaches extreme capacity (around 99%), Claude Code automatically triggers a compacting routine that summarizes the sprawling conversation, preserves critical facts, and resets context consumption down to approximately 15% to 20%. However, waiting for automated compaction means working through prolonged stretches of sluggish, degraded reasoning. Ferreira encourages developers to take control of this threshold manually: as soon as session usage crosses 50%, evaluate whether to execute `/compact` proactively to restore crisp reasoning, or reset the conversation entirely with `/clear`.
- **The Dumb Zone**: Coined by Dexter Horthy of HumanLayer, describing the accuracy and latency drop-off when context usage exceeds 40% to 50%.
- **Proactive Compacting**: Running `/compact` summarizes message history and shrinks context back down to roughly 15%–20% before quality deteriorates.
- **Fresh Sessions**: Ferreira cautions against relying exclusively on compaction indefinitely: “Don't try to keep with the same session forever, just running the compact.”
---
[29:23](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1763s) Managing Project Memories and Pruning Stale Auto-Memories
Claude Code includes persistent memory capabilities that automatically retain developer preferences across sessions in a dedicated project memory file. Through auto-memories, Claude infers lasting preferences from conversational remarks. For instance, if a developer remarks, "I prefer to see this type of information as a diagram," Claude stores an internal directive to default to diagrammatic outputs for similar inquiries across that repository in perpetuity.
While convenient, persistent memories pose long-term risks if left unmanaged. Preferences established for a specific, transient task remain pinned to the project context indefinitely, consuming token budget and skewing future outputs long after their relevance expires. Developers can inspect and manage these entries using `/memory`. Emphasizing the importance of periodic memory hygiene, Ferreira jokes about his own eye-opening experience auditing his personal ChatGPT memories, where he discovered the assistant had inexplicably started calling him "Emily." Because stored instructions inevitably become outdated, regularly pruning project memory files ensures the assistant stays cleanly aligned with current project requirements.
- **Auto-Memories**: Claude autonomously detects and records developer preferences (such as requesting diagrams) into local project memory files.
- **Context Creep**: Stored memory files load into session context permanently, creating persistent overhead if temporary instructions are never removed.
- **Memory Auditing**: Running `/memory` allows developers to view and purge outdated or nonsensical entries that have outlived their usefulness.
[31:22](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1882s) Direct Bash Execution and Sensitive Context
Gui Ferreira confesses an everyday habit: whenever he needs to commit code, he simply asks Claude to commit it for him because having Claude compose the commit messages is effortless and comfortable. However, for deterministic developer tasks such as `npm run`, `dotnet run`, or `dotnet test`, delegating through natural language reasoning is unnecessary. Instead, typing an exclamation point (`!`) enters direct Bash mode. Every command entered after the exclamation mark executes straight in bash, entirely bypassing Claude's reasoning loop so it does not waste tokens pondering what to do with a tool like `git status`.
Despite skipping the initial reasoning step, developers must remain cautious about security and token usage: whatever the command outputs gets captured and injected straight back into Claude's context window. Ferreira warns: “So, if it's something that is exposing sensitive information, don't do it in the context of Claude because eventually it will go into the context window.”
[32:25](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1945s) Resuming Sessions: `--continue` and `--resume`
Switching tasks across days or weeks often leads to lost context. Ferreira describes an instance where he had to suspend client work in Portugal before flying to Oslo to deliver a workshop and this presentation. To focus completely, he closed every application and workspace on his laptop, knowing he would need to pick the project back up the following week.
```mermaid
flowchart TD
accTitle: Session Continuity Flow
accDescr: Diagram illustrating how Claude Code restores past project work via continue or resume commands.
subgraph ResumingSession["Session Restoration Commands"]
A["Prior Client Project Context"] --> B{"Choose Method"}
B -->|`--continue` / `/continue`| C["Instant Reload: Most Recent Conversation"]
B -->|`--resume` / `/resume`| D["Interactive List: Pick Any Historical Chat"]
end
C --> E["Seamless Task Continuation"]
D --> E
```
To bridge interrupted development cycles, Claude Code provides session restoration commands:
- `--continue` (or `/continue`): Automatically steps back to inspect your most recent activity in that repository and immediately resumes the session right where you left off.
- `--resume` (or `/resume`): Presents an interactive history of past conversations in the project, allowing you to select and resurrect the exact session thread needed.
[33:30](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2010s) Detached Development with `/remote-control`
Context switching is taken a step further with mobile and out-of-office workflows using `/remote-control`. Ferreira recounts an urgent family situation where his father needed a ride home from a hospital appointment while Ferreira was under tight project deadlines. Normally, such a conflict forces a bad compromise—arriving late for family or falling behind on deliverables.
Instead, Ferreira initiated `/remote-control`, which establishes a secure tunnel directly with Anthropic. Leaving his laptop open at home, he hopped in the car with just his mobile phone and continued his programming session seamlessly. He uses this technique frequently: once a plan is established, he sends Claude off on execution, leaves his desk for a walk, and receives push notifications on his phone whenever permission is required to proceed.
Addressing the audience's skepticism about boundary-setting, Ferreira explains: “We might have a discussion about work-life balance, I know. Uh, but I honestly believe that it's better this way than being always stressed that you can't do anything.”
[34:56](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2096s) Multimodal Prompting: Voice Mode and Image Inputs
Reflecting on pre-pandemic office dynamics, Ferreira recalls how visiting a colleague's desk to explain a bug frequently led to solving it mid-sentence—classic rubber duck debugging. Talking aloud sparks cognitive connections that are often stifled when typing into a prompt box. To solve this, Claude Code includes an integrated voice interface invoked via `/voice`. Once enabled, holding the spacebar triggers active audio listening so you can dictate your instructions freely.
Ferreira acknowledges that spoken prompts may feel unstructured, but reassures that modern models handle stream-of-consciousness logic effortlessly: “However, the LLM doesn't care if you ramble, okay? It'll find meaning.” Even if you realize a mistake mid-speech, the transcribed prompt can be tweaked manually before submission.
Beyond voice, multimodal inputs extend to graphics for UI and front-end development:
- **Terminal Pasting**: Developers can paste screenshots directly into the terminal prompt. (On macOS, paste via `Control+V` rather than `Command+V`).
- **Drag-and-Drop**: Image files can be dragged directly onto the active terminal window.
- **Visual Grounding**: Screenshots of websites, designer mockups, or Figma exports provide visual reference anchors, enabling Claude to write styling and markup against the concrete visual rather than relying solely on descriptive text.
[37:52](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2272s) Parallel Workflows: Git Worktrees, Color Tagging, and Autonomous Loops
The traditional advice of focusing on one task at a time creates friction with AI tools; waiting idly for an agent to read, think, and generate output becomes tedious. Ferreira notes that modern developers increasingly run parallel workflows across separate terminal sessions. To prevent Git conflicts when working on multiple features, bug fixes, or code reviews within the same repository simultaneously, developers can rely on Git worktrees—effectively allowing parallel virtual checkouts of different branches at the same time.
Managing numerous open terminals simultaneously introduces visual clutter, but Claude Code offers terminal organization utilities:
- `/color`: Assigns an explicit visual color scheme to the conversation.
- `/rename`: Re-labels the terminal session (e.g., distinguishing a red `Bugfix #X` session from a blue `Feature #Y` session) to enable instant visual scanning across windows.
To minimize the constant friction of babysitting interactive permission prompts across multiple concurrent agents, Claude introduces two automation mechanisms:
1. `/call`: Allows defining a complex, end-to-end task bound by a strict stopping condition or measurable goal (such as instructing Claude to generate an invoice endpoint and refusing to stop until an automated integration test produces a valid invoice PDF).
2. `auto mode`: Claude autonomously evaluates bash commands, running those it recognizes as safe without pausing for manual user approval.
3. `Claude agents`: Launching via `claude agents` brings up a centralized orchestration dashboard—similar to agent modes in IDEs like Cursor or Codex—allowing developers to oversee and monitor several background tasks at once.
[41:32](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2492s) Managing Parallel Workflows and Extending Claude as a Platform
Wrapping up his discussion of task management, Gui Ferreira highlights the utility of tracking tasks directly within Claude Code—monitoring what is currently in progress, what is blocked waiting for user input, what background processes are still running, and what has finished. For developers who want to advance multiple workstreams in parallel on the same project, consolidating everything into a unified session interface eliminates the mental friction of juggling separate terminal windows. As Gui acknowledges, workflow preferences are deeply personal: “It’s not for everyone, I would say. You might be used to one of the approaches and you prefer that one, but that's that's fine.”
Transitioning to his next core theme, Gui urges developers to stop viewing Claude Code merely as an editor extension or an interactive coding assistant and start treating it as an extensible computing platform. Modern agent architectures provide numerous extension points—ranging from specialized sub-agents to custom skills—allowing developers to define and plug in bespoke tooling alongside Claude's native capabilities. Understanding how these extension hooks fit together transforms Claude Code from a simple chat interface into a programmable runtime for development workflows.
[42:31](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2551s) Saving Money and Catching Errors with Post-Tool-Use Hooks
Among the extension mechanisms available in Claude Code, Gui singles out hooks as an underappreciated feature that developers should be using far more frequently. Configured inside `settings.json` (the same configuration file used to define explicit permission denials), hooks allow users to register automated commands around tool executions, such as `post_tool_use`. Whenever Claude finishes executing a tool, the configured post-tool hook fires automatically. Crucially, this execution takes place entirely outside of Claude’s context window, ensuring that automated verification steps do not consume API tokens or drive up usage costs.
```mermaid
flowchart TD
accTitle: Claude Code Post-Tool-Use Hook Execution Flow
accDescr: Diagram contrasting token-heavy prompt instructions with out-of-context post-tool hooks in settings.json.
subgraph PromptApproach["Anti-Pattern: CLAUDE.md Instructions"]
A["Claude executes edit tool"] --> B["Prompt re-reads instructions: 'Always run tests'"]
B --> C["Test output injected into context window"]
C --> D["High token consumption & cost"]
end
subgraph HookApproach["Recommended: settings.json Hook"]
E["Claude executes edit tool"] --> F["post_tool_use hook fires"]
F --> G["Test suite runs locally outside context"]
G -->|"Success"| H["Session continues silently"]
G -->|"Failure"| I["Execution halts immediately"]
end
```
Gui frames this approach through the lens of test-driven development and cost efficiency. Many developers clutter their `CLAUDE.md` files with blanket instructions like "always run the test suite after editing," which burns prompt tokens on every turn and relies on the model reliably remembering to follow through. A post-tool hook offloads that responsibility to a deterministic local command. Explaining his underlying philosophy, Gui states: “I like to save money, and I like to spot my mistakes as soon as possible, okay?” If a change breaks the build or fails a test, the hook halts the process immediately, catching errors before bad code compounds into wasted tokens.
Turning to what he calls everyone's favorite topic, Gui discusses agent skills. While the developer community often treats skills as downloadable prompt templates consisting solely of a `SKILL.md` instruction file, Gui argues that limiting skills to static text recipes misses their true potential. In Claude Code, an agent skill is a self-contained package of files. The model automatically loads the skill’s top-level description into its operational context, ensuring Claude knows when to invoke it organically or via an explicit slash command (such as `/<skill-name>`).
Rather than restricting these directories to markdown instructions for code reviews or workflows, developers can bundle runnable scripts directly inside the skill. Gui shares a recent situation where he needed Claude Code to interface with an external API containing several legacy endpoints he only called occasionally. While his initial instinct was to build a full Model Context Protocol (MCP) server, he quickly recognized that hosting and managing a server for infrequent calls was unnecessary overhead: “Why going through that pain of hosting a server for that? While I actually have already a Python script in my machine that I used to use, so I will just put that Python script inside of my skill with a readme that explains how to use that Python script.” Packaging the script, its execution guide, and troubleshooting reference documentation inside a custom skill created a modular, portable utility without any architectural bloat.
- Skills can contain executable Python, Bash, or PowerShell scripts rather than relying exclusively on LLM natural language generation.
- Reference documentation inside a skill can outline fallback strategies, such as explicit error-handling steps or API parameter definitions.
- Skills are triggered automatically by Claude based on task context or manually invoked using the slash command format.
[46:11](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2771s) Built-in Anthropic Skills: /patch, /simplify, and /loop
While many developers spend time shopping for community skills or writing their own, Gui notes that Anthropic has already bundled the internal tools used by their own engineering teams directly into Claude Code. These built-in slash commands solve common architectural and operational bottlenecks right out of the box, requiring zero external configuration:
```mermaid
flowchart LR
accTitle: Built-in Anthropic Claude Code Skills
accDescr: Visual summary of the three built-in slash commands explained by Gui Ferreira: patch, simplify, and loop.
subgraph BuiltInSkills["Native Claude Code Skills"]
direction TB
P["/patch"] --> P_Desc["Splits large refactors into 5–50 units & runs parallel agents"]
S["/simplify"] --> S_Desc["Audits code complexity & applies direct simplifications"]
L["/loop"] --> L_Desc["Polls external systems e.g. CI/CD at scheduled intervals"]
end
```
The first built-in tool Gui highlights is `/patch`, which is designed for sweeping code modifications that touch dozens of files. Instead of trying to force a massive refactoring through a single linear context, `/patch` breaks the assignment down into 5 to 50 distinct units of work and spins up parallel sub-agents to tackle them concurrently. For code reviews, Gui recommends `/simplify` over homegrown review prompts. He observes that generative models frequently over-engineer their solutions, making an automated counterweight essential: “The other one that I use a lot, and I see most people creating skills to do code review, you actually have a great one over there. The name is just {slash} simplify. They basically look how complex is the thing that you have implemented, because LLMs have a tendency to complexity.” Running `/simplify` prompts Claude to assess structural bloat, propose cleaner alternatives, and implement the necessary trims automatically.
Finally, Gui demonstrates `/loop` to eliminate tedious manual waiting. Developers frequently push commits to GitHub, trigger CI/CD pipelines targeting testing or QA environments, and repeatedly refresh browser dashboards waiting for deployments to complete. With `/loop`, users can command Claude to poll an endpoint or query a GitHub MCP server at a fixed frequency (for example, every five minutes). Because the loop runs autonomously in the background, developers can continue working on other tasks until Claude alerts them that the build has succeeded or failed.
[48:48](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2928s) Scoping MCP Servers with .mcp.json and Headless CLI Scripting
As the ecosystem around Claude Code expands, developers increasingly turn to plugin marketplaces and public repositories to acquire collections of hooks, skills, and Model Context Protocol (MCP) servers. However, Gui warns of a major operational pitfall: when plugins and MCP servers are installed globally into a user profile, their tool definitions and instructions are loaded into Claude’s context window on every single run. If a developer works across different clients or repositories—such as Project A hosted on GitHub and Project B hosted on Bitbucket—a global configuration unnecessarily bloats the Bitbucket session with GitHub-specific tools and schemas, burning tokens and polluting model context.
To solve this problem, Gui advises defining project-specific configurations by placing an `.mcp.json` file directly in the repository root. This ensures that only the MCP servers required for that specific project are loaded into memory when Claude Code launches. It also guarantees that team members checking out the repository share an identical toolchain: “There, you can write the the MCPs that you want to share with your team, and you guarantee that they are only loaded in the context of that project.”
Beyond interactive terminal sessions, Gui highlights Claude Code's non-interactive execution capability, which he describes as "endless mode" (or headless mode). By passing the `--print` flag along with a prompt—such as `claude --print "summarize this folder"`—Claude processes the instruction without prompting the user for initial terminal input:
- Passing the `--print` argument allows Claude Code to execute without opening an interactive conversational prompt loop.
- Standard output can be piped directly between command-line utilities, enabling developers to incorporate Claude into shell, Bash, and PowerShell scripts.
- The model functions as an automated reasoning engine within existing build and operational pipelines without pausing for human intervention.
[51:38](https://www.youtube.com/watch?v=zaDbZt40kRg&t=3098s) Stepping Beyond Code: Productivity and Note-Taking
Having concluded the architectural tour of Claude Code as an extensible development platform, Gui transitions into the final chapter of his presentation: using Claude Code for activities beyond pure software engineering. Admitting his personal obsession with productivity frameworks and self-optimization routines, he candidly confesses with a laugh: “As a context, I'm quite addicted to productivity things, okay? Maybe that's the reason why I'm doing this talk now that I think about it.”
Among the various productivity habits he has pursued over the years, personal note-taking has consistently been one of the hardest disciplines for him to maintain effectively. While acknowledging that every developer recognizes the immense long-term value of maintaining structured, comprehensive notes, the actual mechanics of capturing, organizing, and synthesizing information on a daily basis remain an ongoing struggle—setting up the stage for how Claude Code can function as a broader, agentic AI assistant in daily knowledge work.
[52:05](https://www.youtube.com/watch?v=zaDbZt40kRg&t=3125s) Augmenting Obsidian Notes with Claude Code
Gui Ferreira explains that throughout his career, note-taking tools always created friction because he felt like he was serving the software rather than having it work for him. Having cycled through OneNote, Apple Notes, Notion, and Obsidian, he struggled with keeping up until he realized the fundamental nature of Obsidian: it is essentially an application sitting on top of plain Markdown files stored locally on his own machine. Because LLMs handle Markdown exceptionally well and Claude Code naturally operates on local files, pairing Obsidian with Claude Code proved to be an ideal match.
By opening Claude Code inside his Obsidian vault directory, Gui can query his personal notes directly, request summaries across documents, and ask Claude to establish connections between disparate thoughts. While Obsidian's native visual graph views look impressive when displayed on a presentation slide, Gui bluntly dismisses them as practically useless compared to direct programmatic interactions. Furthermore, because Claude Code can be embedded as a terminal pane directly inside the Obsidian user interface, users can fetch online resources, query documentation, and inject summaries into their local Markdown files seamlessly—treating personal knowledge management identically to code development. Gui highlights Anthropic's product portfolio (claude.ai, Claude Cowork, and Claude Code), emphasizing that Claude Code is by far the most capable for terminal-savvy users.
```mermaid
flowchart LR
accTitle: Claude Code and Obsidian Integration
accDescr: Flow showing how local Markdown notes in an Obsidian vault are queried and updated by Claude Code inside an embedded terminal.
subgraph ObsidianApp["Obsidian Environment"]
Vault["Markdown Vault (Local Files)"]
Term["Embedded Terminal"]
end
Web["External Web / URLs"] --> Term
Term <-->|"Read & Write"| Vault
Term -->|"Summarize & Link"| Claude["Claude Code Engine"]
Claude --> Term
```
- “One of the problems with the name Claude Code is that it creates the assumption that it's only for code, but it's for so much more than that,” Gui Ferreira argues, urging the audience to look past the branding.
- Note-taking systems tested before this workflow: Microsoft OneNote, Apple Notes, Notion, and Obsidian.
- Anthropic's three primary interface tiers discussed: claude.ai (web), Claude Cowork, and Claude Code (CLI).
---
[53:51](https://www.youtube.com/watch?v=zaDbZt40kRg&t=3231s) Work Summaries and Headless Log Processing
Preparing for quarterly performance reviews or weekly 1-on-1 check-ins with management is notoriously tedious, requiring developers to dig through scattered notes, Jira boards, and calendar entries to prove what they accomplished. Because Claude Code retains context regarding project repositories and tracks code contributions across local directories, Gui shows how it can be leveraged to generate thorough summaries of recent engineering activities. Developers can even encapsulate this recurring process into a reusable custom skill placed within a specific project folder or in their global user profile, allowing them to invoke a single command right before meeting with their manager.
Beyond interactive chat, Claude Code can function as a programmatic command-line utility using its headless execution mode. Rather than spending time writing custom shell or Python scripts to parse massive directories of text, developers can invoke Claude Code directly against large batches of raw files—such as application log directories or Windows Event Viewer error dumps. The tool reads the logs, analyzes the underlying errors, outputs a structured summary to standard out, and can easily have its output piped into an output file for subsequent reporting.
- “Claude maintains a context of what you have been doing, so you can ask for a summary of what you have done last week or what you have done last month, and then you can have that, for example... create a skill, put that skill somewhere inside of a folder or in your user profile, and when the moment comes to send that to your boss, you just run that skill and you have the thing ready.”
- Headless execution allows Claude Code to behave like a standard Unix utility without launching an interactive terminal session.
- Output can be redirected or piped directly to other CLI tools or saved into Markdown/text reports.
---
[55:37](https://www.youtube.com/watch?v=zaDbZt40kRg&t=3337s) Organizing Chaotic Downloads and the `/insights` Command
Gui shares a relatable everyday problem: a local `Downloads` folder that only grows in one direction until disk space warnings appear. Reluctant to purge files out of fear of deleting something irreplaceable—even if it is likely useless—he recently faced a bloated directory containing 1,626 separate files and nested folders. Manually triaging hundreds of mixed items was too time-consuming, so he pointed Claude Code directly at his `Downloads` directory with a simple natural-language prompt instructing it to inspect every file and organize the entire folder by file type and purpose.
The automated organization instantly grouped clutter into distinct buckets such as installer packages (which could be safely discarded immediately) and stray code checkouts (which were redundant because the authoritative versions lived on GitHub). With the remaining important documents categorized neatly, clearing hundreds of gigabytes of disk space took minutes instead of hours.
To wrap up his NDC AI talk, Gui stresses that viewing Claude Code strictly as an autocomplete or bug-fixing utility misses its true value as an adaptable everyday workstation assistant. He urges every developer in the room to execute at least one built-in command as soon as they get home: `/insights`. Running this slash command analyzes your personal usage patterns and history, delivering an analytical breakdown of how you interact with the CLI, recommending custom skills that fit your specific routines, and highlighting bottlenecks in your daily engineering workflows.
- “If you don't run any of those commands, at least run one that you can learn a lot with it, because I learned more with that command than by reading LinkedIn posts, to be honest: that is the `/insights`.”
- Scale of clutter resolved: 1,626 root items plus arbitrary subdirectories categorized automatically.
- Key categorized directories identified for deletion: redundant software installers and obsolete local git checkouts backed up remotely.
- The `/insights` command generates custom workflow recommendations and tailored skill ideas based on real session history.
## Notable quotes
> [52:05](https://www.youtube.com/watch?v=zaDbZt40kRg&t=3125s) One of the problems with the name Claude Code is that it creates the assumption that it's only for code, but it's for so much more than that — Gui Ferreira
> [31:22](https://www.youtube.com/watch?v=zaDbZt40kRg&t=1882s) if it's something that is exposing sensitive information, don't do it in the context of Claude because eventually it will go into the context window. — Gui Ferreira
> [34:56](https://www.youtube.com/watch?v=zaDbZt40kRg&t=2096s) the LLM doesn't care if you ramble, okay? It'll find meaning. — Gui Ferreira
## Mentioned
Gui Ferreira, Claude Code, Anthropic, NDC AI, ETH Zurich, Dexter Horthy, HumanLayer, VS Code, ChatGPT, Model Context Protocol, ASP.NET Core, FastEndpoints, Claude Opus, Claude Sonnet, claude.ai, Claude Cowork, Figma, Git, Cursor, Codex, GitHub, Bitbucket, Obsidian, Microsoft OneNote, Apple Notes, Notion, Jira, Windows Event Viewer
## Video description
This talk was recorded at NDC AI in Oslo, Norway.
#ndcai #ndcconferences #developer #softwaredeveloper
Attend the next NDC conference near you:
https://ndcconferences.com
https://ndc-ai.com/
Subscribe to our YouTube channel and learn every day:
/ @NDC
You've installed Claude Code. You've asked it to write some code. You may have even let it refactor a file or two. But there's a good chance you're only scratching the surface.
In this session, I'll share what I've learned from using Claude Code daily and teaching it to developers in workshops. We'll go into the features that change how you work. Things like shaping Claude's behaviour through CLAUDE.md, building your own commands and skills, automating feedback loops, and understanding the small configuration details that most people overlook.
We'll also look at use cases beyond software development. We'll use Claude Code as an actual AI-assistant, not only a code-assistant.
This isn't a getting-started guide. It's a tour of the parts of Claude Code that only become visible once you stop treating it like an autocomplete tool.
If you use Claude Code but feel you're not getting the most out of it, this session will help you see what it can really do.
Software engineer Gui Ferreira argues that most developers use only 5% to 10% of Claude Code's capabilities, treating it merely as an autocompletion or bug-fixing tool rather than an extensible computing platform and daily workstation assistant.
Curating Lean Context and Tiered Configuration (4:42)
Developers frequently overfill their root CLAUDE.md files, leading to documentation sprawl and degraded agent performance. Ferreira highlights an ETH Zurich benchmark showing that exhaustive, over-prescribed context files reduce task accuracy and inflate token costs by over 20%, whereas concise, human-curated instructions consistently outperform machine-generated context dumps. To keep instructions lean, Ferreira applies a three-part pruning filter: keep instructions only if they apply to 95% of tasks, move directory-specific rules to scoped files or agent skills within the .claude directory, and omit static structural details like folder trees that frontier models navigate autonomously.
To balance team standards with personal preferences, configuration should follow a strict hierarchy. While the root CLAUDE.md file establishes committed project-wide guidelines, personal preferences like test-driven development can be isolated in an uncommitted .claude/CLAUDE.local.md file. Machine-wide styling or concise tone preferences belong in a global CLAUDE.md in the user's home profile directory. Furthermore, developers should secure their environments using settings.json to define permission_denied rules, preventing Claude from automatically reading sensitive files like .env or executing commands like dotnet user-secrets.
Controlling Reasoning Depth and Managing Context Bloat (20:53)
Session performance often degrades due to context window mismanagement. Citing Dexter Horthy's concept of the 'dumb zone,' Ferreira points out that reasoning accuracy and latency drop significantly once session context usage exceeds 40% to 50%. Rather than waiting for automatic compaction at 99% capacity, developers should proactively run /compact to compress conversation history down to roughly 15% to 20%, or clear the session entirely with /clear. Developers can also audit baseline token bloat via /context, which frequently reveals forgotten Model Context Protocol (MCP) servers or custom skills silently consuming 4% to 6% of context in a newly opened session.
Workflow efficiency also relies on managing model effort and branching. While complex architectural planning requires high-reasoning models like Claude Opus or adjusting /effort, downstream code generation can be swapped mid-session to cheaper, faster models. Single prompts requiring deep thought can be targeted using the 'ultra think' trigger. When Claude takes a wrong turn, Ferreira advises using /rewind or pressing double Escape to revert to earlier interaction checkpoints, rather than submitting sequential correction prompts that drag failed research and flawed code into the ongoing context.
Extending Claude with Hooks, Scripts, and Scoped MCPs
Rather than relying solely on prompting Claude through CLAUDE.md to run test suites after changes, teams can configure post_tool_use hooks in settings.json. These hooks run local verification scripts out-of-context immediately after Claude executes an edit tool, catching breaking changes instantly without burning API tokens. For custom capabilities, Ferreira argues that agent skills should not be limited to markdown recipes; developers can bundle executable Python, Bash, or PowerShell scripts directly inside skill directories alongside documentation, avoiding the overhead of hosting dedicated MCP servers for intermittent tasks.
Native slash commands also resolve operational bottlenecks out of the box: /patch breaks complex, multi-file refactors into 5 to 50 smaller units across parallel agents, /simplify reviews code to strip away model-generated over-engineering, and /loop repeatedly polls background systems like CI/CD deployments. To prevent token pollution across client projects, Ferreira advises scoping MCP servers per repository using a root .mcp.json file rather than installing them globally across the entire machine.
Operating Beyond Code in Non-Interactive and Knowledge Work (52:05)
Claude Code provides extensive utility outside of conventional software programming. Because knowledge management tools like Obsidian store notes in local Markdown files, developers can embed Claude Code directly inside their vaults to query personal notes, summarize information across disparate documents, and pull external web research straight into their personal knowledge base. Using headless execution with the --print flag, Claude operates non-interactively as a Unix utility, enabling developers to pipe terminal output directly into shell scripts or process large log dumps without an interactive chat prompt.
Ferreira also demonstrates delegating administrative and operating system clutter to the agent. Claude can parse contribution histories across local repositories to generate weekly or quarterly work summaries for management reviews, or triage messy directories. Pointing Claude at a cluttered Downloads folder containing 1,626 items allowed Ferreira to automatically categorize files and safely purge redundant local checkouts and installers in minutes.
Ferreira concludes by urging developers to move past conversational autocomplete habits and treat Claude Code as an adaptable system utility. To identify personal workflow bottlenecks and receive tailored recommendations for custom skills, he recommends that practitioners run the built-in /insights command on their own session histories.
Source quotes
[52:05] Gui Ferreira: One of the problems with the name Claude Code is that it creates the assumption that it's only for code, but it's for so much more than that
[31:22] Gui Ferreira: if it's something that is exposing sensitive information, don't do it in the context of Claude because eventually it will go into the context window.
[34:56] Gui Ferreira: the LLM doesn't care if you ramble, okay? It'll find meaning.
Original transcript
[0:06] Good morning. So, looks like many of us
[0:09] are actually super interested into Cloud
[0:12] Code. Looks like according to the room.
[0:14] The question is, do we actually know
[0:17] Cloud Code that well?
[0:19] So,
[0:20] out of curiosity, yesterday I decided to
[0:23] look around and try to find an answer
[0:25] for the following question. How many
[0:27] features do you have inside of Cloud?
[0:30] It's actually hard to find how many they
[0:32] are, but I could find the number
[0:35] of slash commands that you have
[0:37] available at the moment. So, 96. And
[0:40] honestly, I didn't look into Twitter
[0:42] today, so I don't know if it's actually
[0:43] 97, because things are going too fast.
[0:47] Super fast. It's hard to keep up with
[0:49] what is happening.
[0:50] So, during the past few months, I have
[0:53] been running workshops with companies
[0:56] where I actually teach about
[0:59] Anthropic Cloud Code thing.
[1:01] And I realized one thing, is that often
[1:03] we start with Cloud Code,
[1:05] and since it's so powerful, you start
[1:08] writing code, you start debugging code,
[1:10] you start
[1:11] fixing bugs, all of that stuff, and
[1:13] quickly you stop.
[1:15] You stop for a reason, because it's so
[1:17] powerful that you see a new
[1:20] increment in your performance, you know,
[1:22] in your productivity, that you actually
[1:24] don't feel the need to dig deeper into
[1:26] the tool.
[1:27] Is that helpful?
[1:29] But there's something more that you can
[1:30] do. I
[1:32] At least I believe so. So, I believe
[1:34] that most of us get to the 5 to 10% and
[1:38] we don't keep digging, because it's
[1:39] actually that powerful. And also, if you
[1:42] do that in January, now there's so many
[1:45] new things and it's hard to keep up. So,
[1:48] my goal for this session today is the
[1:50] following. I want to go through four
[1:52] different types of things with you.
[1:54] Things that you can set up and take
[1:56] advantage of them in your Cloud Code
[1:58] installation
[2:00] forever. Uh things that you can do in
[2:02] your daily workflow. So, small tips,
[2:04] small tricks that you can do in your
[2:05] day-to-day to improve your cycle.
[2:08] Also, I want to go through things that
[2:10] make Cloud actually extensible and how
[2:13] do I use them in my day-to-day.
[2:16] And finally, I want to touch some other
[2:18] use cases besides code. So, we tend to
[2:20] think about Cloud Code, but there's
[2:22] something more that you can do with it.
[2:25] That's the goal for today.
[2:26] I just want to warn you something
[2:28] important about this talk.
[2:30] This is not a getting started talk with
[2:32] Cloud Code, okay? So, the goal of this
[2:34] talk is for those that once in There was
[2:37] one day that they opened the terminal
[2:39] and they run Cloud.
[2:41] So, they tried something with Cloud. I
[2:43] want you to share with you things that
[2:45] come from my experience that I I
[2:47] actually use.
[2:49] So, I have no affiliation with Anthropic
[2:52] at all. So, this is not a sales talk.
[2:54] This is basically a talk coming from
[2:55] someone that uses it every day,
[2:58] teaches these things to other people,
[3:00] and um actually really likes it.
[3:03] So, I want to share not only the
[3:05] features, I want to share uh the types
[3:07] of problems that they solve in my
[3:09] day-to-day. And I will go through those
[3:11] that I use a lot
[3:13] by those categories.
[3:15] Also, it's important to say that this is
[3:17] basically a rapid-fire type of talk.
[3:21] So, I will share with you roughly 40
[3:24] tips during 1 hour.
[3:27] So, keep up.
[3:28] Uh
[3:29] the goal is not to go deep into each
[3:31] one, is to share what you can do with
[3:33] it, okay? And then
[3:35] if by the end of this session,
[3:37] tomorrow or next week, you can apply two
[3:40] or three of those 40, for me is a new
[3:42] success. It means that you took
[3:44] something home that you were not
[3:46] familiar and that can actually help you
[3:48] in your day-to-day. Okay? That's our
[3:50] mission for today. I hope you are happy
[3:52] with that because we are about to start
[3:54] a journey.
[3:55] So, the first thing that we need to
[3:57] clarify is where do you run Cloud Code?
[4:01] We can install it in many different
[4:02] ways. You can run it as a a terminal,
[4:05] okay? You open your terminal of choice
[4:07] and you start working or it can be
[4:09] something like uh the desktop
[4:11] application nowadays. Cloud has one or
[4:14] inside of an IDE like VS Code.
[4:16] >> [snorts]
[4:17] >> The thing is
[4:19] the terminal is where usually you get
[4:20] the features first.
[4:22] So, usually I use that one. That's why
[4:24] you'll see a ton of print screens of uh
[4:27] features inside of um
[4:29] the terminal. That doesn't mean that
[4:30] they are not available on the other um
[4:33] platforms, but keep that in mind.
[4:34] Usually they come first uh in the the
[4:37] terminal. So,
[4:39] that's why I usually use the terminal.
[4:42] So, let's go to the setup type of
[4:43] things. The things that you want to do
[4:45] once and benefit from them
[4:48] for the rest of your of your life using
[4:50] Cloud Code until Cloud Code is replaced
[4:52] forever, I think.
[4:54] So, the first thing that is important to
[4:55] mention
[4:56] is
[4:57] we need to talk about the most important
[4:59] artifact that you have inside of a
[5:01] project where you use Cloud Code. That
[5:03] is the cloud.md.
[5:05] If you come from other tools, you might
[5:06] be familiar with agents.md. So, cloud.md
[5:09] is the same thing.
[5:11] So, it's basically the heart and the
[5:12] soul
[5:13] of the agent that you have in your
[5:15] project. So, you describe so many
[5:17] different things there from rules to uh
[5:20] what's inside of that project, the
[5:21] frameworks, uh how to run certain
[5:23] commands and all of that.
[5:27] Sometimes, I come to the conclusion
[5:28] after working for a while with one
[5:30] project that eventually I start seeing a
[5:32] ton of duplication.
[5:34] I start seeing that I have information
[5:36] in many different places. For example,
[5:38] rules in two different markdown files,
[5:41] uh descriptions inside of a readme, and
[5:44] inside of the cloud.md, uh instructions
[5:47] on how to run the pipeline inside of a
[5:50] readme.md, and also inside of my uh
[5:53] cloud.md. And you can actually avoid
[5:55] that duplication, okay?
[5:57] The cloud.md can use the at symbol to
[6:00] import a given file. You just need to
[6:01] mention the path, and when the cloud
[6:04] session starts, it will load not only
[6:07] the cloud.md, but also will load those
[6:09] files that you mentioned there. Okay?
[6:11] So, it's one quick tip to improve and
[6:14] avoid uh duplication, okay? And that's
[6:16] um extremely useful, and you can even
[6:19] use it with uh for uh files that are not
[6:21] markdown files. For example, if you have
[6:23] a the schema of an API, and you you feel
[6:25] it's important for that project, you can
[6:27] do it that way. You can even have a
[6:30] relative path over there.
[6:33] But don't take this too far.
[6:35] Why?
[6:36] I used to believe that uh the cloud.md
[6:38] was so important that any single thing
[6:41] that I could think about it, I would add
[6:43] it to to that. So, it would be extremely
[6:45] descriptive. So, last year, if I was
[6:47] here delivering the same talk, I would
[6:49] say "Anything that comes to mind, please
[6:52] write it to the cloud.md in order to
[6:54] improve the performance of your agent."
[6:57] Things changed.
[7:00] This thing is so fresh, so new that many
[7:02] of the things that we say, they are
[7:04] actually based on feelings, on personal
[7:06] opinions, on things that we read here,
[7:09] we read there, we listen uh someone
[7:11] talking about them during a talk, or
[7:13] anything like that.
[7:15] But actually, they might not be true.
[7:17] So, someone took the the challenge of
[7:19] running a study at ETH Zurich. So, they
[7:23] did the following. They um
[7:25] went through a study with many different
[7:27] projects. They created the cloud.md and
[7:30] the agents.md inside of those uh
[7:32] projects. They used ones without the
[7:35] cloud.md, others with uh
[7:37] machine-generated cloud.md, and another
[7:40] ones with human-curated cloud.md.
[7:43] And they reached one conclusion, that
[7:45] when you have something so specific with
[7:47] so many different instructions,
[7:48] eventually you will see the performance
[7:51] will start to to drop
[7:53] and the cost will actually increase
[7:57] more than 20%. Okay? And nowadays,
[8:00] tokens are quite expensive.
[8:02] So, what should you do instead?
[8:05] Nowadays, I follow three questions that
[8:07] I try to find an answer for them in
[8:09] order to review my cloud.md, okay? Uh
[8:12] so, as a summary, they concluded that
[8:14] it's better a human to maintain that
[8:16] cloud.md than relying on the machine to
[8:19] update the cloud.md.
[8:20] So, what types of questions you can ask
[8:23] when you are reviewing the cloud.md?
[8:25] The first one
[8:27] is
[8:28] do I need this for every single type of
[8:30] thing? So, in the context of this
[8:32] project, 95% of the conversations that I
[8:36] will have, is this information actually
[8:38] relevant to produce a better outcome?
[8:41] If not,
[8:43] maybe let's move it away. Let's
[8:45] evaluate. Otherwise, let's keep it
[8:47] there.
[8:48] Second question.
[8:50] Is it something specific that I only run
[8:52] once in a while?
[8:54] Is it something specific that only
[8:56] matters for the given type of files?
[8:58] Imagine that you have a a project that
[9:01] has different technologies inside like
[9:03] .NET and JavaScript and Python. Some
[9:05] rules might only be required for one of
[9:08] the projects. For example, the
[9:09] instructions to run the tests will be
[9:11] specific depending on the technology.
[9:13] So, on such cases, you can do one of two
[9:16] things. Either create an agent skill and
[9:18] move those instructions over there
[9:20] or create something that we call a cloud
[9:23] rules file.
[9:24] Those files live inside of your .cloud
[9:27] folder and the benefit is that you can
[9:29] use a cloud pattern, so you can filter
[9:31] to given type of files or to a given
[9:33] folder. So, they only apply when you get
[9:36] there, when you are working with those
[9:37] files.
[9:38] And finally, an important one
[9:42] that you should ask is,
[9:44] does my agent is capable of finding it
[9:47] alone?
[9:49] Because sometimes I used to write things
[9:51] like the
[9:52] complete
[9:53] uh tree of files and folders. So,
[9:55] basically the overview how to navigate
[9:57] my code. Where do I put controllers?
[10:00] Where do I put models? Where do I put
[10:01] views? Where do I put services? My
[10:03] infrastructure uh folder, what's inside?
[10:06] So, I will try to describe that to have
[10:08] a a clear landscape, like a map, so the
[10:11] agent would know where I like to put
[10:13] things.
[10:14] But actually, agents are quite smart
[10:16] nowadays.
[10:17] So, those instructions eventually might
[10:20] be outdated, and now you have a problem.
[10:23] And actually, for an agent,
[10:25] understanding what you have inside of
[10:26] your
[10:27] uh disk, inside of your folder, is not
[10:29] that hard. So, the recommendation from
[10:32] ETH Zurich is actually don't add those
[10:34] things that the agent can
[10:36] quickly find it. Okay? So, for those,
[10:39] skip those.
[10:41] That's the main idea. Then it comes the
[10:43] the the second level, that is
[10:46] when I work with the cloud.md,
[10:47] especially in projects with other
[10:49] people, sometimes there's a couple of
[10:51] things that they are actually personal
[10:53] preferences.
[10:55] For example, I'm a huge fan of
[10:57] test-driven development, but I work with
[10:59] people that did actually don't like it.
[11:01] Okay? So, I don't want to force the
[11:03] others to to go through it. There's a
[11:05] couple of things that are specific to
[11:07] me.
[11:08] How can I do it?
[11:09] Because my
[11:10] default uh idea was basically, okay,
[11:13] let's put the that thing inside of my
[11:16] cloud.md.
[11:18] But actually, cloud.md might not be the
[11:20] one.
[11:21] Because the cloud.md is the one that you
[11:22] share with your team, but actually you
[11:24] you have one that is specific for you.
[11:27] If you go to your .cloud folder, and you
[11:29] create a cloud.local.md, you can git
[11:32] ignore that file and claw will pick it
[11:34] uh as well.
[11:36] So, it will put your own preferences
[11:39] into the context window and will use
[11:41] them.
[11:42] And you don't impact the other people.
[11:44] But now let's say that this preference
[11:46] is actually something that I like to use
[11:48] it in every single type of thing that I
[11:50] do with claw code.
[11:52] On such cases, that's not the place
[11:54] because this will be living inside of
[11:56] your repo. What do you do is that you go
[11:59] to your user profile. So, on Windows is
[12:02] a slightly different place. It's on your
[12:05] app data folder. On Mac OS is something
[12:08] like that. And you'll find a dot claw
[12:10] folder over there and you can create a
[12:12] claw.md that applies to every single
[12:14] session that you open with claw in your
[12:16] own machine.
[12:17] Let's say that you like concise
[12:19] language, okay? Or you will you prefer
[12:21] communication with bullet points. Just
[12:24] write it there and it it will applies in
[12:26] every single session that you have with
[12:27] claw code. Extremely useful for that
[12:30] type of scenario.
[12:33] Now, one extremely important.
[12:35] And please do this one, okay? That is
[12:37] the following.
[12:39] Do you know that claw code can be quite
[12:40] helpful, right? It's always saying, "You
[12:42] are right. Let's do it. No, I was wrong.
[12:45] Sorry for that." And when you ask claw
[12:47] to do something, you will actually try
[12:49] to to achieve the mission. It's like
[12:52] the goal of his life if he have a life.
[12:55] Maybe one day will have, I don't know.
[12:57] But you give a mission and it claw claw
[12:59] code will start working on that until
[13:01] the moment that it's actually done. So,
[13:04] let's say that I'm fixing fixing a bug
[13:07] regarding a database connection, okay? I
[13:09] have an exception. I pick that
[13:11] exception. I prompt claw saying, "Please
[13:13] help me fix this thing." Claw goes
[13:16] during a journey to find the reason and
[13:18] eventually will realize that it's it
[13:20] might be a problem with connection
[13:22] string. So, it starts looking around
[13:24] into things like your settings, into
[13:26] things like your environment files, into
[13:29] things like your app settings depending
[13:31] on the technology that you use.
[13:33] And that's actually a problem.
[13:35] Why? Because now those will go to your
[13:38] context window.
[13:39] And if they go to your context window,
[13:42] they go to Anthropic.
[13:43] Okay? That's not great.
[13:45] And the problem is that by default the
[13:47] tools don't lead you to take the best
[13:50] decisions in these cases. So, what you
[13:52] should do after this session is to go to
[13:55] your project where you work with your
[13:57] team, create a file named settings.json
[14:01] inside of your .cloud folder,
[14:03] and there you have a JSON that is a
[14:05] collection where you say permission
[14:06] denied.
[14:08] And there you can put a deny to read
[14:09] files like environment files,
[14:11] app settings files, all of those types
[14:14] of files. Also, you can deny deny
[14:17] running certain types of bash commands.
[14:19] For example, if any of you is a .NET
[14:21] developer, there's one that is the .NET
[14:23] user secrets. You can deny that one and
[14:25] no one in your team can do it.
[14:29] Ideally, no one brings production keys
[14:31] into the local repo, but it happens, you
[14:34] know that, right? So, you want to be the
[14:37] one taking care of the rest of the team,
[14:39] so you want to put that over there.
[14:41] And also, the important note is that the
[14:43] same thing that I told you about the
[14:45] different .cloud.mds, you can do the
[14:47] same with the settings. That means that
[14:49] you can go to your global profile in
[14:51] your machine and go to the settings.json
[14:54] that will be there, and you can deny
[14:56] certain types of things so you don't
[14:58] forget them next time that you are
[14:59] working with another project. Okay? This
[15:02] is super important.
[15:04] >> [snorts]
[15:06] >> Last tip for setup type of things.
[15:10] Sometimes I'm working with Claude, and I
[15:12] start a conversation inside of a given
[15:14] folder in a given repo. I keep working
[15:17] with it for for a while. I might open a
[15:20] couple of terminals as well to work in
[15:22] different things. Eventually, I don't
[15:24] know uh where I'm working
[15:26] because I'm doing several things at the
[15:27] same time and now I don't know
[15:30] what's the thing that I'm that I'm
[15:31] doing, where I'm working, what's what
[15:33] I'm seeing. And actually, you can do
[15:35] that thing. So, you can create a status
[15:37] line that will always show up under the
[15:40] place where you write the prompt
[15:42] and you can prompt Claude to add things
[15:44] to there. And you can use natural
[15:45] language for that, by the way. So, you
[15:47] can say things like those. Those are my
[15:49] favorite ones. Git branch, the model
[15:52] that I'm using, the context that is
[15:54] available. For example, am I consuming
[15:56] 2% or
[15:57] 80%? You can see that available
[16:01] at any given moment while you are
[16:03] working, okay? And if you don't like
[16:05] those, do the following. Ask Claude
[16:08] which ones are available and Claude will
[16:10] suggest a couple of things that might be
[16:12] useful. So, you can always do that.
[16:15] So, with this, I close my topic of
[16:18] things that you have for uh today today.
[16:21] Now, let's go to the big one, okay? So,
[16:24] be ready.
[16:25] Daily workflow type of things.
[16:28] If you have been using Claude or Copilot
[16:30] or whatever, I
[16:32] I sus- suspect that you are already
[16:34] using something like the plan mode.
[16:37] So, the idea with the plan mode is that
[16:39] before asking your agent to go and do
[16:42] something and achieve a mission, first
[16:44] come up with a plan, with a strategy,
[16:46] and and then let's execute that
[16:48] strategy. Otherwise, we are kind of like
[16:50] trying to go to a given place without
[16:53] knowing where we should go. We are just
[16:55] trying, okay? Eventually, we'll get
[16:57] there, but it's not the most efficient
[16:58] way of doing it.
[17:01] One thing that
[17:02] used to happen a lot to me is that I
[17:04] will see the plan. I will ask Claude to
[17:06] to plan the change and I would read that
[17:08] plan.
[17:09] Yes, because sometimes I read it and
[17:12] I would see something that I don't like
[17:14] the strategy or something like that and
[17:16] my default way to fix it would be to
[17:19] prompt again. So,
[17:21] instead of doing X, let's do Y.
[17:24] Something like that.
[17:25] Actually, you can do something a bit
[17:27] smarter, especially when it's something
[17:29] uh smaller, like a a tiny little change
[17:32] inside of that document. There's one or
[17:34] two lines that you don't like.
[17:36] And that is as simple as the following.
[17:39] When you do the shift tab thing to go
[17:40] into plan mode, and you get the plan,
[17:43] just use control G. Why? Control G will
[17:47] basically open the plan as a markdown
[17:49] in edit mode.
[17:51] So, you can navigate through that file,
[17:53] adjust whatever you want, save it, go
[17:56] back to the terminal, and keep going.
[17:58] Basically, you are sharing the plan with
[18:00] Claude Claude. Okay? If you are in the
[18:02] context of something like VS Code, it
[18:04] actually seems so um integrated that
[18:08] looks like magic, okay? To a point. So,
[18:10] do that. See the plan. If you find one
[18:12] or two lines that you don't like the
[18:14] strategy, instead of prompting again,
[18:16] just go there,
[18:17] control G, open the markdown, edit one
[18:20] or two things, save it, and keep going.
[18:23] Okay? You save time, you save tokens,
[18:25] you save um
[18:26] your sanity as well.
[18:30] Talking about plans, uh my favorite
[18:31] thing nowadays is the following. I I I
[18:34] love to come up with plans first. I love
[18:36] something named uh specification driven
[18:38] development, that is when you first come
[18:40] up with a spec, then uh that leads a new
[18:42] document, and then you prompt your
[18:45] agent. Let's implement this thing.
[18:49] I like that approach.
[18:50] But sometimes, I come to the conclusion
[18:52] that
[18:53] I'm not seeing the full uh picture when
[18:55] I prompt uh to the system to come up
[18:57] with the the specification.
[19:00] And also, I realize that often, Claude
[19:03] is trying to fill the gaps with
[19:05] assumptions. And I don't know the the
[19:07] assumptions until the moment that
[19:09] something is actually implemented.
[19:11] So, nowadays, I do the following. I ask
[19:13] Claude to interview me.
[19:14] There's something inside of Claude that
[19:16] is named the ask users ask user question
[19:19] tool
[19:20] uh that is a tool that they call
[19:22] whenever you are in the plan mode.
[19:24] Usually, you might see something like a
[19:26] multi options like, "Do you want to do
[19:28] this with option A or with option B? Or
[19:31] do you want to suggest something else?"
[19:33] That's the ask user question tool in
[19:35] action.
[19:37] What I like to do is to force Claude to
[19:40] use it. So, I will prompt Claude with
[19:41] things like, "Please interview me about
[19:43] every single thing that I have inside of
[19:45] this document that might be an
[19:47] assumption. Don't stop until every
[19:49] single thing is clear."
[19:51] And I will start understanding that I
[19:53] have so many different assumptions that
[19:54] I never thought about them.
[19:56] Okay? This is extremely useful. You can
[19:58] also apply to the the specification
[20:00] again based on that clarification
[20:03] process. It's super useful.
[20:06] Regarding to plans again, other thing
[20:08] that uh
[20:10] it tends to happen is that first, you
[20:11] come up with a plan. You it comes back
[20:13] with "Do you want to go with approach A
[20:16] or approach B?" For example, "Do you
[20:17] want to go with MVC controllers or do
[20:20] you want to use plain endpoints like a
[20:23] minimal API or fast fast endpoints style
[20:26] of application?" And you might choose
[20:28] one of them. Let's say, "I want to go
[20:29] with MVC style of application."
[20:32] Then, it starts up implementing the
[20:33] thing. And by the end, you look into the
[20:35] code and you'll see,
[20:38] "I don't like this. This seems too much
[20:39] for what the application is doing."
[20:42] So, what do you do?
[20:43] You prompt Claude again asking to
[20:46] uh
[20:46] re- convert the thing into the fast
[20:49] approach, the minimal API approach. So,
[20:52] you prompt again.
[20:53] What is happening during that moment is
[20:54] that basically, you are adding a new
[20:56] message into the context.
[20:58] And all the past research, all the past
[21:01] implementation stays there.
[21:04] So, the past implementation will
[21:06] influence will impact the future
[21:09] iterations.
[21:10] What is not great, besides the fact that
[21:12] consumes tokens as well. So, what can
[21:15] you do instead?
[21:16] Actually, Claude Code has kind of like a
[21:18] time travel thing inside. The same way
[21:21] that you can do a Git revert, you can do
[21:24] a rewind with Claude Code.
[21:26] So, if you want to get back in history
[21:28] in the conversation, you just do double
[21:30] escape or {slash} rewind, and you can
[21:33] always go back and pick I want to go
[21:36] back to this point where I decided to go
[21:37] with option A, and I actually want to
[21:40] prompt it in a different way.
[21:42] So, instead of trying to fix it by
[21:44] moving forward, give one step back
[21:47] to then go forward, okay? That's the
[21:49] tip.
[21:53] Regarding plans, we now have a strategy,
[21:55] right? So, uh one thing that you should
[21:58] know about plans is that that's the
[21:59] moment where you are actually doing the
[22:02] heavy lifting work, okay? That's where
[22:04] reasoning is actually important. Having
[22:06] a powerful model is actually super
[22:08] important.
[22:09] But then, once you have a proper plan
[22:11] that is detailed,
[22:14] sending that that plan to a a cheaper
[22:16] model
[22:18] is a good idea, because you will save
[22:20] time, you will save tokens, and it's
[22:22] just following instructions. A cheaper
[22:24] model can do it as well.
[22:26] So, actually, you can switch the model
[22:29] in the middle of a conversation. You
[22:31] don't need to take that decision and
[22:32] stick with it forever.
[22:35] But better than that, and by the way,
[22:36] this is great when you use that status
[22:38] line, because you can see in the status
[22:39] line which model you are using at the
[22:41] moment.
[22:42] But better than this is the fact that
[22:44] each model is not by the fact that you
[22:46] are using Opus or Sonnet, that you have
[22:50] basically two levels. There's several
[22:52] levels inside of each model.
[22:55] Each model can run in different effort
[22:58] levels.
[22:59] So, you can actually run a {slash}
[23:00] effort and say, from from now on I'm
[23:03] using Opus but with a extra extra I
[23:08] effort.
[23:09] >> [snorts]
[23:09] >> You will spend more money, okay?
[23:11] But for complex tasks is extremely
[23:14] useful.
[23:15] By doing this you are actually changing
[23:17] the
[23:19] the rest of the conversation. From that
[23:20] point on all the different things that
[23:22] you'll be doing will be running with
[23:24] extra uh level, okay? It might be to
[23:28] to a higher level or to a lower level,
[23:30] okay? You can do that both both ways.
[23:34] But what if I want to run just one
[23:36] prompt, okay? The one like think about
[23:38] this or fix this bug just that prompt
[23:41] with proper effort with extra effort.
[23:44] They have something that I think is
[23:45] quite funny that is this idea of the
[23:47] whole thing. And the cool thing is that
[23:49] she if you write ultra think inside of
[23:51] the prompt, you write the prompt and you
[23:53] write ultra think, it will actually look
[23:55] like a rainbow.
[23:57] I don't know why.
[23:58] Uh
[23:59] but it's basically saying, "Okay, this
[24:00] prompt is super important. Do your best.
[24:03] Uh use the tokens that you need to to
[24:05] use to find a solution for this."
[24:08] That's the
[24:09] the big idea.
[24:11] Now I need a break for
[24:14] be able to keep up with the rest.
[24:17] Sorry for this.
[24:19] Okay, so
[24:20] now you send Claude on a journey,
[24:23] implement this thing, get back to me
[24:25] when you have a solution for this
[24:26] complex thing that I'm doing.
[24:29] What's next? The next thing is that you
[24:32] will start working, but do you know that
[24:34] sometimes Claude is working and you need
[24:36] to wait for it to to finish to ask a
[24:38] question.
[24:39] Because if you write another prompt, it
[24:41] will actually go to the queue and will
[24:43] only be executed afterwards, right?
[24:46] So what you can do instead is to run
[24:48] something like this, {slash} BTW or
[24:51] {slash} by the way. That's the the
[24:53] thing. So Claude is working for uh 5
[24:56] minutes. Uh you are waiting, you need to
[24:59] ask something about the the past
[25:01] conversation.
[25:02] You don't want to start a new session,
[25:04] otherwise you don't have the context.
[25:05] So, what you do? You run the {slash} by
[25:07] the way, and you ask the question. It
[25:09] runs it in in parallel, and you get the
[25:11] answer, and it keeps going.
[25:13] No blocker.
[25:14] Super useful.
[25:16] >> [snorts]
[25:18] >> Now, we need to talk about cost, right?
[25:20] So, um and I will s-
[25:22] show you this because this has a ton of
[25:24] information that can be useful to
[25:26] understand how do you use Claude?
[25:28] And also because it's awesome when you
[25:30] do an end-of-year review, and you want
[25:32] to post on LinkedIn.
[25:34] That is, you can use the {slash} usage,
[25:36] and you'll get a a graphic like this,
[25:38] where you can see uh the model that you
[25:40] used the most, when do you use the model
[25:42] the most. Um
[25:45] there's a ton of
[25:46] a tons of things here regarding each
[25:48] model that you use.
[25:49] Uh also, if you have an an API key-based
[25:53] consumption model, you can see the cost
[25:55] as well without leaving your terminal,
[25:57] and you find more details here than in
[25:59] the website, okay? That's why is
[26:02] interesting as well.
[26:04] Cost is highly related to context, we
[26:07] know that. So, context is basically our
[26:09] context window, is the things that we
[26:11] send in the conversation to Anthropic,
[26:14] so the prompt is evaluated. Each prompt
[26:17] is basically a new conversation, so we
[26:19] need to maintain that.
[26:22] We know that. And at at a given moment
[26:24] when you see your application at 60% of
[26:27] context, you can always run the {slash}
[26:29] context, and you'll see a cool
[26:31] visualization like this with all of
[26:33] that.
[26:34] But what [snorts] I want to challenge
[26:35] you to start doing is the following, and
[26:37] you can do that today or tomorrow.
[26:40] Open a session with Claude.
[26:42] An empty one, okay? Just a new one, and
[26:45] run {slash} context, and see what is
[26:47] there.
[26:49] Because more often than not, you have a
[26:50] ton of things
[26:51] uh inside of your context window that
[26:54] they are only used once in a while.
[26:56] Things like MCP servers that you
[26:58] installed back in the day just to
[27:00] explore them.
[27:01] Or things like you installed a
[27:04] an ancient skill from someone because it
[27:05] looks cool, but you don't use it in the
[27:07] day-to-day.
[27:08] All of those are loaded by default and
[27:10] they will be there. And when you run
[27:12] this in an empty session, if you see
[27:14] that you have for example 4%, 5%, 6% of
[27:18] context window taken without doing
[27:20] anything,
[27:22] it's a good way to do a an audit to
[27:25] that.
[27:26] And why that's so important, if for
[27:28] example with Opus we have 1 million
[27:30] tokens,
[27:31] for a reason.
[27:33] While 1 million is the limit of the
[27:35] model,
[27:36] actually, from experience of many
[27:38] different people, there's many different
[27:40] reports, we don't have a study that
[27:42] proves this, is one of those things that
[27:44] might be a feeling, honestly,
[27:46] but [snorts] according to many different
[27:47] people,
[27:48] once you go above the 40 to 50%
[27:51] consumption of the context window, you
[27:53] get into something that a guy named
[27:55] Dexter Orthy from Human Layer calls it
[27:59] the dumb zone.
[28:00] Why? You actually start seeing that the
[28:03] the quality of the responses, the
[28:05] accuracy, the
[28:07] uh the grounding of the response is not
[28:09] as good. And also it takes more time.
[28:13] And what happens when you reach the
[28:14] limit?
[28:16] Usually, Claude will go and run
[28:17] something that we call the compact.
[28:20] It runs it automatically. You don't need
[28:22] to do anything.
[28:23] What is the compact? It's basically
[28:25] looking to that huge conversation,
[28:27] coming up with a summary, and replacing
[28:29] most of the messages with a summary. So
[28:31] now we have
[28:32] an idea of what we're working on, we
[28:35] keep the main facts, and we can keep
[28:37] going on with the conversation. So we go
[28:38] from the 99% of consumption to maybe 15
[28:42] or 20%.
[28:44] But actually, you can be the one
[28:45] triggering that. And
[28:47] often we don't do it. We ignore it.
[28:50] So, I challenge you that from now on,
[28:52] once you see that you are above the
[28:55] in the dump zone, okay, above the 50%
[28:58] type of thing, start thinking, "What if
[29:00] I run the compact here?"
[29:02] Because, it's actually useful and you'll
[29:04] see the difference
[29:05] afterwards.
[29:08] Don't try to keep with the same session
[29:09] forever, just running the compact. It's
[29:11] important to frequently do the other
[29:14] thing that is a new conversation. So,
[29:17] start in the conversation again, the
[29:18] slash clear, as well.
[29:21] >> [snorts]
[29:23] >> One important thing, talking about
[29:24] context, is that actually there's
[29:26] something inside of Claude that can
[29:28] become a problem eventually,
[29:30] once you work in the same project for a
[29:32] long time.
[29:33] There's something that is called the
[29:35] memories. You are familiar with them.
[29:38] In the keynote, we we learn how
[29:40] dangerous they can be.
[29:43] But, memories can be quite useful
[29:45] because they save preferences and the
[29:48] cool thing is that actually Claude has
[29:50] something named auto memories. So, it
[29:51] can actually understand from the meaning
[29:53] that it should start something into the
[29:55] a memory file.
[29:57] Let's use an example.
[29:59] If you are working with Claude and you
[30:01] get an answer and you write back
[30:03] something like, "I prefer to see this
[30:05] type of
[30:06] information as a diagram."
[30:09] Claude might look into that and will
[30:11] realize, "Oh, next time that I have same
[30:13] type of question, I will come up with a
[30:15] diagram."
[30:16] That goes into a memory. Memory is just
[30:18] a file.
[30:19] The thing is that that information will
[30:21] stay there
[30:22] forever, okay, in that project.
[30:25] And eventually, you might not need that.
[30:27] It might be something that you asked
[30:28] just for the context of the project that
[30:31] you were working on or the activity that
[30:32] you were doing.
[30:33] And now that thing is going to your
[30:36] context. So, what you can do is actually
[30:39] run the slash memory to see what you
[30:41] have there, running an audit. By the
[30:43] way, one of the most interesting
[30:44] experiences in my life uh
[30:47] um I hope my wife is not uh watching
[30:50] this
[30:51] uh
[30:52] was going to my chat GPT memories uh
[30:55] you should try it because sometimes chat
[30:58] GPT was calling me Emily.
[31:01] I don't know why. Uh
[31:03] and uh I realized that they store things
[31:05] that don't make sense at all. And going
[31:07] to this type of memory sometimes to
[31:10] clean those memories is actually useful
[31:12] and you improve the outcomes by the end
[31:14] because memories
[31:16] tend to be a bit um
[31:18] they have a lifetime, okay? Eventually
[31:20] they are outdated. They are not useful
[31:22] at all.
[31:24] >> [snorts]
[31:25] >> S- Regarding saving context,
[31:28] um
[31:29] I have this uh habit that when I need to
[31:31] commit something, I ask Claude to commit
[31:33] for me, okay? I have to confess.
[31:35] Uh why? Because it's so comfortable to
[31:38] have Claude writing the commit message.
[31:40] But for other things like running an NPM
[31:42] or NPM run or .NET run or .NET test,
[31:45] something like that, you can actually
[31:47] run the exclamation point.
[31:50] With the exclamation point, you go into
[31:51] bash mode. That means that every single
[31:53] thing that you type after will go be
[31:56] executed as a bash command, okay? And
[31:59] will skip the reasoning process of
[32:01] thinking about your instruction. So,
[32:03] Claude doesn't look into git status and
[32:05] thinks about what I need to do with
[32:07] this. We skip that part.
[32:09] But keep in mind that the result of that
[32:11] command will go back into the context
[32:13] window, okay? So, if it's something that
[32:16] is exposing sensitive information, don't
[32:18] do it in the context of Claude because
[32:20] eventually it will go into the context
[32:22] window. It might be a problem.
[32:25] It might happen to you. Uh it happens to
[32:27] me a lot. For example, um couple of
[32:29] weeks ago, I was working um
[32:32] with a project with a client and um I
[32:35] had to stop it because
[32:37] I came to um Oslo. I'm from Portugal.
[32:41] And I stopped that. I closed all of the
[32:44] things that I have around in my in my uh
[32:46] laptop, so I would be focusing the
[32:49] workshop that I was delivering in and in
[32:50] this talk.
[32:52] Next week, I want to get back to that
[32:53] work.
[32:55] One thing that you can do if you want to
[32:56] get back to a previous thing that you
[32:58] were doing and you want to keep going
[33:00] work is actually running that is named
[33:02] the slash the dash dash continue or
[33:04] slash continue or the dash dash resume.
[33:07] The continue will basically go back in
[33:09] time and look what's the most recent
[33:12] thing that you are doing. Okay, let's
[33:14] keep going with that one.
[33:15] The resume will display all the past
[33:19] conversations in that uh
[33:21] in that project and you can pick the one
[33:23] that you want to go back. So, even when
[33:25] you are moving back and forward between
[33:26] tasks, it can be uh extremely useful.
[33:30] But more more useful than that is the
[33:31] following.
[33:33] Um
[33:34] starting time. A couple of weeks ago, uh
[33:37] my um my father had to to go to to an an
[33:41] exam at an hospital and he asked me to
[33:43] go to pick him at the hospital.
[33:46] But I was working in a project and I was
[33:47] in a rush.
[33:49] Usually, what will happen is that I
[33:51] would even be late or
[33:55] late for picking my father at the
[33:57] hospital or late in the project. So,
[33:59] what I've done is that I actually run
[34:01] the slash remote control.
[34:03] This will open a tunnel with Anthropic
[34:06] and then I pick my phone. I go to
[34:08] whatever I need to go. My laptop is at
[34:10] home and I keep working through my
[34:12] phone, okay? I keep prompting.
[34:14] This one is extremely useful because
[34:16] nowadays, I do this not only for this
[34:18] type of tasks, but also when I'm for
[34:21] example, I run I define my plan. Now, I
[34:24] just need to execute the plan. I pick my
[34:26] phone. I go for a walk and then I get a
[34:29] notification from Claude asking, "Do you
[34:31] want to continue? Do you approve this
[34:33] change or something like that? And I
[34:34] just say yes or no and things things
[34:37] keep going and I get the feature that I
[34:39] want. And I don't need to stay at the at
[34:41] the desk.
[34:43] We might have a discussion about
[34:44] work-life balance. I know.
[34:47] Uh but I honestly believe that it's
[34:48] better this way than being always
[34:50] stressed that you can't do anything.
[34:52] Okay? So, trust me on this one.
[34:56] Another thing that actually changed the
[34:58] way that I [snorts] work um and I get if
[35:00] you don't agree with me, okay? That is
[35:02] the following.
[35:04] Do you remember uh
[35:05] back in the days where when everyone was
[35:07] at the same time at the at the office?
[35:10] It might still be your case, but before
[35:12] the pandemic uh it was everyone was in
[35:15] in that environment. So, I I could go to
[35:18] my colleague's desk and I would start
[35:20] explaining a problem that I'm having and
[35:22] in at the middle of the conversation I
[35:23] would say,
[35:25] "Ignore it. I know what to fix it."
[35:26] Right? We call to that uh rubber
[35:28] ducking, right?
[35:30] For some reason when we speak,
[35:33] there's some connections that start to
[35:35] appear. But when we we write,
[35:37] it's a bit harder.
[35:39] At least to me with me is is that way
[35:41] that it works.
[35:43] The cool thing is that Claude exposes a
[35:45] voice mode.
[35:46] So, if you go to your Claude uh code and
[35:49] you write and you type /voice, you can
[35:52] enable the voice mode. From that moment
[35:54] on, if you just press your spacebar, is
[35:58] it basically is listening to you.
[36:00] So, you can write the prompt with voice.
[36:03] You might say, "Okay, but when I'm
[36:04] talking, I'm not as uh eloquent as when
[36:07] I'm writing. My thoughts are not as
[36:10] um
[36:11] expressive or not as well defined."
[36:14] That's fair, okay? I understand that.
[36:17] However, the LLM doesn't care if you
[36:19] ramble, okay? It'll find meaning. And
[36:22] oftentimes in the middle, you will
[36:24] understand that actually you were wrong
[36:27] and you can always go and edit the
[36:29] prompt that will come from that. Using
[36:31] voice is one of those things that
[36:32] actually changed the way that I work.
[36:34] I get it. If you work in something like
[36:36] an open office, it's a bit awkward.
[36:39] Uh,
[36:40] but when you are at home, at least try
[36:41] it.
[36:43] Talking about this voice thing, uh, so
[36:46] we have text, we have audio, right? We
[36:48] are prompting through audio. So, to this
[36:50] we call the multimodal LLMs. There's the
[36:54] other component that is
[36:56] >> [snorts]
[36:56] >> images.
[36:58] For those that work with UIs, like
[37:00] front-end development,
[37:01] you can actually paste images into the
[37:04] terminal, okay? Not only into the
[37:05] applications that Claude exposes, into
[37:07] the terminal as well. Just one quick
[37:10] note, if you are on on macOS, that's
[37:12] actually control. So,
[37:15] command V doesn't work, it's control V.
[37:18] And you can also drag and drop images
[37:19] into the terminal, which is quite cool.
[37:22] And the cool thing about this is that
[37:23] you have an idea of what work you want
[37:25] to build. For example, you go to the
[37:26] website of a given company or to,
[37:29] uh, from a designer or you want someone
[37:31] send you a a Figma or something like
[37:33] that, and you take a print a print
[37:35] screen of something, you can paste it on
[37:37] the conversation and ask Claude to do
[37:39] something similar. Now, Claude has not
[37:41] only the text part, but a visual
[37:44] against,
[37:45] uh, that can compare to, okay? To find
[37:47] information from that, uh, visual. It's
[37:50] extremely useful.
[37:52] The other thing that is changing the way
[37:53] that we work is basically that
[37:56] we used to be so focused in one task,
[37:58] and everyone would say, "Just do one
[38:00] thing, and when you finish, go to the
[38:02] next one."
[38:03] Nowadays, I think that everyone expects
[38:05] that we are working in many things in
[38:06] parallel.
[38:08] Because otherwise, we just set ask the
[38:10] agent to do something, and we are just
[38:12] waiting.
[38:13] And waiting. And waiting. And then you
[38:15] ask, "Do you accept? Accept?" And
[38:18] waiting. And waiting. Which is quite
[38:20] boring. So, we start working in many
[38:22] different things at the same time.
[38:24] Working in different projects, that's
[38:26] fine, okay? You just open two terminals,
[38:29] there's no big deal. The problem is that
[38:31] most of us work with Git, and sometimes
[38:34] you want to work in two different things
[38:35] for the same project, like a feature,
[38:38] fixing a bug, doing a code review, all
[38:41] of those at the same time.
[38:43] Actually, now you can do that with work
[38:45] trees. It's a bit strange concept
[38:47] because we didn't used to use it, but it
[38:49] was there.
[38:50] But, it's basically like having the same
[38:52] branch,
[38:53] uh branching out in virtual branches.
[38:55] Think about it in that way. So, this
[38:58] opens this possibility.
[39:01] But, you'll have a problem because now
[39:02] you are working in several different
[39:04] things at the same time. So, you might
[39:06] have many different terminals at the
[39:07] same time, and you don't know where you
[39:09] are doing what, okay, at a given point.
[39:11] So, what do you do for that?
[39:13] There's actually something named the
[39:14] slash color and slash
[39:16] uh rename. So, you can pick a color for
[39:19] that conversation and assign a name. So,
[39:21] you can say, "This one is the bug fix
[39:23] number X. This one is the feature number
[39:27] uh Y." And when you look into the
[39:29] different terminals, you will use the
[39:31] visual recognition to understand that
[39:34] the blue one is the feature, the red one
[39:36] is the bug, and all of that, okay? Tiny
[39:39] little detail, but when you are trying
[39:40] to work with many different things at
[39:42] the same time, it's actually great.
[39:45] The other thing that is not great is
[39:47] that when you are working in parallel,
[39:49] uh you're going to babysit Cloud Code
[39:51] because it's always asking for
[39:52] permissions. Do you accept this? Do you
[39:54] accept this? Do you accept that?
[39:56] Nowadays, there's a new feature. This
[39:57] one is quite new, okay? It's not one
[39:59] from the old ones, it's one from the new
[40:01] ones, that is the call.
[40:03] Now, you can write slash call and define
[40:06] what you need Cloud to do,
[40:08] and also a condition to stop.
[40:11] Basically, think about this like a a
[40:13] measurable objective. You can say
[40:16] something like, "Implement this." Let's
[40:18] say that we are building uh an invoice
[40:20] generator." Something like that. I can
[40:22] prompt Claude, "Build me the invoice
[40:24] generator feature and endpoint and only
[40:27] stop when you have a test that generates
[40:30] an an invoice that has a PDF like this
[40:32] one, for example."
[40:34] So, this way Claude goes in the journey
[40:36] and won't stop until that moment. Okay?
[40:40] Tokens? Yes, a lot. Uh
[40:42] also this one goes quite well together
[40:44] with another the thing new that I don't
[40:46] have in the slides, that is the auto
[40:48] mode. The auto mode is a way that Claude
[40:50] is basically taking the decision if
[40:52] something is safe to accept or not, like
[40:54] a bash command, for you, okay? You don't
[40:57] For those that we recognize that they
[40:59] are safe, Claude will take the decision
[41:02] for you, but that also has an extra cost
[41:04] in the day-to-day.
[41:05] Final thing about working in parallel is
[41:08] that now you can do this.
[41:11] You can run Claude agents. So, if you
[41:13] have ever used something like the uh
[41:16] cursor in the agent mode or
[41:19] Code X, you can start Claude with agent.
[41:22] So, when you run Claude, instead of just
[41:24] starting with Claude, start with Claude
[41:25] agents and you go into the agents
[41:27] dashboard.
[41:28] From there, you can start seeing things
[41:30] like this. For example, do I have any
[41:32] task that is in progress that needs an
[41:34] input, that is blocked? Do I have
[41:36] anything that is still working or every
[41:39] single thing is completed? And you can
[41:41] start generating new tasks. So, if you
[41:43] want to work in things in parallel for
[41:44] the same project, this one is great uh
[41:48] and super helpful because it's easier to
[41:50] do it through one single window than
[41:52] having to to have to manage many
[41:54] different tasks, for example, okay? Uh
[41:57] it's not for everyone, I would say. You
[41:59] might be used to one of the approaches
[42:01] and you prefer that one, but that's
[42:03] that's fine.
[42:06] Let's go to the platform thing. So, I
[42:09] see Claude not only as a development
[42:10] tool, but also as a platform, because we
[42:12] can extend Claude. You might be familiar
[42:15] with things like uh sub-agents, for
[42:17] example, or uh many other concepts like
[42:19] skills, for example. All of those are
[42:22] basically extension points. So, Claude
[42:24] is running a set of tools, and they are
[42:26] finding a way that you can define your
[42:28] own tools to run.
[42:31] But, there's one that I really like to
[42:32] use, and I don't see people using it as
[42:34] often and as as I believe they should,
[42:36] that is this idea of hooks. And I like
[42:39] to use hooks for the following.
[42:43] I like to save money, and I like to spot
[42:45] my mistakes as soon as possible, okay?
[42:48] It might be because I was used to
[42:49] test-driven development, but when
[42:51] something is wrong, I want to stop. So,
[42:53] what you can actually do is to go to
[42:55] your settings.json, the same one where
[42:57] you define the permissions deny, and you
[43:00] can have there uh post tool use, that is
[43:03] a hook. A hook is basically, let me tell
[43:06] Claude that
[43:07] after doing this thing, for example,
[43:08] since it's a post, let's run this
[43:11] command that I have here. So, that
[43:12] command will run outside of the context
[43:14] window, okay? So, it doesn't consume
[43:17] your tokens, so you save money, okay?
[43:19] That's the one of the important parts,
[43:21] but also can stop you during the
[43:23] process, and you can understand that
[43:24] something went wrong.
[43:26] Okay, that's extremely useful. Uh and
[43:28] this is is one of those
[43:30] that I recommend, especially if nowadays
[43:32] you have inside of your um
[43:34] uh
[43:35] Claude.md instructions like the
[43:37] following.
[43:38] Uh always run the test by me. If you
[43:40] have something like that, instead of
[43:42] consuming tokens through the Claude.md
[43:44] and expecting that Claude will always
[43:47] run it,
[43:49] use a hook. It's extremely useful.
[43:52] Let's go to the favorite one of most
[43:54] people, that is agent skills. So,
[43:56] everyone has agent skills, everyone is
[43:58] shopping around in the web for agent
[44:00] skills. Agent skills is basically
[44:02] packaging a uh a set of instructions
[44:05] into a set of files,
[44:06] and inside you'll have a description
[44:09] that the LLM will load that description
[44:11] by default. So, Cloud will load that
[44:12] description by default. And when you ask
[44:15] for something that is related to that,
[44:18] Cloud will guarantee that that is
[44:19] invoked. You can also call those skills
[44:22] with the slash command and the name that
[44:24] you defined it.
[44:26] The problem that I see is that we tend
[44:27] to think about skills as just the
[44:29] skills.md file. So, skills.md are
[44:32] basically a recipe. For example, I can
[44:34] have a skill on now I like to review my
[44:37] code and I might have a long readme
[44:40] file, like a markdown file, explaining
[44:42] how do I do that. But they actually can
[44:45] hold different types of things. For
[44:46] example, scripts.
[44:49] If you have things that want sometimes
[44:52] you do in the context of a project, like
[44:54] cleaning up a given folder or moving
[44:58] files around or calling a given API to
[45:01] extract data, you can actually build a
[45:03] skill for that. For example, recently I
[45:06] had to um
[45:08] to integrate into
[45:10] with in Cloud
[45:11] an API uh that have a couple of whole
[45:14] endpoints that I use once in a while and
[45:17] I thought, "Okay, how do I call that API
[45:18] from my um Cloud session?" My first
[45:22] thought was an MCP server because MCP
[45:24] servers is how we see the connection
[45:26] between different
[45:27] services.
[45:28] But then I thought,
[45:30] "Why bothering?
[45:31] Why going through that pain of hosting a
[45:33] server for that?"
[45:35] While I actually have already a Python
[45:37] script in my machine that I used to use,
[45:40] so I will just put that Python script
[45:42] inside of my skill with a readme that
[45:44] explains how to use that Python script.
[45:47] So, it's like packaging a small
[45:48] application inside of your Cloud folder.
[45:51] Just that.
[45:53] It's super useful. And by the way, you
[45:54] can add things like reference
[45:56] documentation
[45:57] for scenarios like, "If this fails, try
[46:00] this." Or, "If this goes wrong, try
[46:02] that. If you don't know this
[46:04] information, it should be that one. So,
[46:06] having a a guide on the the API, for
[46:08] example.
[46:11] Talking about skills, uh
[46:14] I have the feeling that we all uh build
[46:17] our own skills, or we shop around for
[46:20] for skills that others do.
[46:24] What we all ignore
[46:25] the fact that Anthropic
[46:28] exposes the skills that they use in the
[46:29] day-to-day to build Claude code as part
[46:31] of the product.
[46:33] So, you actually have a set of Claude
[46:36] skills inside of the product by default.
[46:38] You don't need to do anything with that,
[46:39] and they are quite cool. One that I use
[46:41] a lot for major refactoring, so if I
[46:44] want to touch a ton of files in my
[46:47] system, is using the {slash} patch
[46:50] um
[46:50] the skill. The {slash} patch will
[46:52] basically do the following. You will
[46:55] split the work in 20 to 50 different
[46:59] 5 to 50 different units of work, then
[47:02] will run several agents to work on those
[47:05] in parallel.
[47:06] So, if you have something like I want to
[47:08] do a major refactoring, I want to
[47:10] upgrade some files, I want to to apply
[47:14] this change to many different files
[47:16] inside of my system, you can use the
[47:17] patch to segregate the work, and you
[47:20] don't need to go through the trouble of
[47:22] implementing that yourself.
[47:24] The other one that I use a lot, and I
[47:26] see most people creating skills to do
[47:28] code review, you actually have a great
[47:31] one over there. The name is just {slash}
[47:33] simplify. They basically look how
[47:35] complex is the thing that you have
[47:36] implemented, because LLMs have a
[47:39] tendency to complexity. So, if you run
[47:41] {slash} simplify, it come back with the
[47:43] recommendations for that, and also can
[47:46] implement the the changes
[47:48] that were proposed. So, instead of
[47:50] coming up with yours, try this once,
[47:53] because they are actually pretty good.
[47:55] The final one is that sometimes you
[47:57] might push something to GitHub, for
[48:00] example. It might trigger a CICD. And
[48:02] now you
[48:04] it's supposed to deploy to the QA
[48:06] environment or to the testing
[48:07] environment, something like that. So,
[48:09] you stay there waiting for that to
[48:11] finish. So, you go to the GitHub
[48:13] dashboard and you refresh the page. Is
[48:16] it finished? Is it finished? It's
[48:17] boring.
[48:18] Actually, you can put your agent doing
[48:20] that. There's something there named
[48:22] slash loop
[48:23] and you define the frequency. For
[48:25] example, every 5 minutes, please do this
[48:28] thing. It might be a prompt. It might be
[48:30] something like calling an MCP server. If
[48:33] you have the MCP server from GitHub, you
[48:35] can
[48:36] integrate those two things and you just
[48:39] wait or you keep going on your thing
[48:42] because you don't need to just look into
[48:43] the loop. You just can keep going. Super
[48:46] useful.
[48:48] Talking about skills and to finalize is
[48:52] everyone
[48:53] is always looking around what others do.
[48:55] Uh, there's many databases nowadays
[48:58] online about skills and all of that.
[49:00] Actually,
[49:02] uh, Antropic has a a marketplace. Feels
[49:05] like a marketplace for plugins. You can
[49:07] go and get a plugin. A plugin is a set
[49:09] of things. Like, let me package um
[49:12] hooks, let me package
[49:15] skills, let me package MCP servers, all
[49:18] combined and distribute that as a a
[49:20] plugin.
[49:22] So, you might install one of those or
[49:24] you might install a package um an MCP
[49:27] server because you see online, "Okay,
[49:28] there's an MCP server for this tool that
[49:30] I use sometimes." The problem is that
[49:33] now all of those things go to your
[49:34] context window because by default they
[49:37] are installed in your user profile.
[49:40] That means that if you are working on
[49:42] project A or in project B and project A
[49:46] uses GitHub, project B uses
[49:49] uh Bitbucket,
[49:51] you'll have on the Bitbucket one, for
[49:53] example, this the skills and the MCP
[49:55] servers of GitHub as well.
[49:58] That's not great. What you can actually
[50:00] do, and also to guarantee that everyone
[50:03] in your team is using the same MCP
[50:04] servers, is that you can go to your
[50:06] folder and just create this file.
[50:09] .mcp.json
[50:12] There, you can write the
[50:14] the MCPs that you want to share with
[50:15] your team, and you guarantee that they
[50:18] are only loaded in the context of that
[50:20] project. So, when you start Cloud inside
[50:23] of that session,
[50:24] you'll have those MCPs. When you go to
[50:26] other project, they are not there. So,
[50:28] you are saving money and also saving the
[50:30] nightmare that some of your some
[50:32] elements of your team are doing one
[50:34] thing, others are doing the other one.
[50:38] One more thing regarding this being a
[50:39] platform. Uh I don't know if you are
[50:41] familiar with this, but you can actually
[50:42] run a Cloud code in endless mode.
[50:46] So, you can run Cloud and Cloud won't
[50:48] wait for you to do anything.
[50:50] So, usually you run Cloud and by the
[50:52] end, you
[50:53] after starting Cloud, you will see Cloud
[50:55] asking for the first prompt, right?
[50:57] Without doing it, nothing happened. But,
[50:59] you can actually run in endless mode.
[51:01] So, if you provide the {dash} {dash}
[51:03] print uh
[51:04] >> [snorts]
[51:04] >> argument, the thing that is there,
[51:06] summarize this folder, will be the
[51:07] prompt.
[51:09] That means that you can do awesome
[51:11] things like
[51:13] piping.
[51:14] That means that inside of scripts that
[51:16] you used to have and complex PowerShells
[51:19] and all of that, you can integrate Cloud
[51:22] for that. And asking Cloud to be part of
[51:24] that process, being the reasoning part
[51:26] of that complex uh script.
[51:29] And it doesn't stop waiting for you.
[51:32] So, this closes um the section of um the
[51:36] platform thing. Let's go to the last
[51:38] one, okay? I hope you are still alive.
[51:41] Um in this one, we are talking about
[51:43] things behind the code.
[51:46] Sometime
[51:47] As a [snorts] context, I'm quite
[51:49] addicted to productivity things, okay?
[51:52] Um
[51:53] Maybe that's the reason why I'm doing
[51:54] this talk now that I think about it. But
[51:56] uh um I'm quite addicted to it and
[51:59] note-taking has been one of those that I
[52:01] always struggle with. I know how
[52:03] important it is to take notes, but I
[52:05] never found the uh tool that I didn't
[52:07] felt like I was
[52:09] working for the tool instead of having
[52:11] the tool working for me.
[52:12] So, I used OneNote, I used the Apple
[52:15] Notes, I used Notion, I used every
[52:18] single thing that you can imagine. I
[52:20] used Obsidian and all of that
[52:22] and always struggled with it.
[52:25] Recently, I was looking into my notes
[52:26] and I thought, wait,
[52:28] this Obsidian thing
[52:30] uh is basically an application on top of
[52:32] Markdown files.
[52:34] Markdown files that are in my machine.
[52:37] AI loves Markdown files.
[52:40] Claude likes files in my machine. So,
[52:42] why not using both together?
[52:45] So, now I have my vault with my notes.
[52:47] Vault is the term of a folder inside of
[52:49] Obsidian
[52:50] that is just plain old Markdown files.
[52:53] And I can ask questions about the things
[52:55] that I write there.
[52:56] I can ask to summarize my notes. I can
[52:58] ask to, for example, pretty cool thing,
[53:01] create connections between those notes
[53:03] and Obsidian will do things like those
[53:06] that are awesome to put in in a
[53:08] in a slide, but they are useless, to be
[53:10] honest.
[53:12] But you can also embed your Claude code
[53:15] as part of the user experience as a
[53:17] terminal, okay? So, when you are working
[53:20] on something or you want to pull
[53:22] information online from a a website to
[53:25] your note, you can do all of that in the
[53:27] same way that you do it with code.
[53:30] One of the problems with the name Claude
[53:31] code is that it creates the assumption
[53:33] that is only for code, but it's so for
[53:35] so much more than that.
[53:37] Claude actually has three products, the
[53:39] claude.com, Claude co-work, and Claude
[53:42] code.
[53:43] Claude code is the most powerful one and
[53:45] in the hands of someone that is
[53:46] comfortable with a terminal
[53:48] is awesome.
[53:51] The other thing that I use Cloud for
[53:53] Do you know when you go to a one-on-one
[53:56] meeting and you need to explain what you
[53:58] have been working or every let's say
[54:01] every 3 months you have your
[54:03] evaluation period and you need to to
[54:06] show your achievements and things like
[54:08] that.
[54:09] That's quite hard because now you need
[54:11] to go back into notes into uh
[54:14] your Jira.
[54:16] Good luck. Uh or you need to go to
[54:19] things like for example um
[54:21] your calendar trying to find what
[54:23] happened.
[54:24] Actually, you can ask Cloud code to do
[54:26] that.
[54:27] Because for example, for code
[54:29] contributions, Cloud has access to
[54:31] those. Go. Cloud maintains a context of
[54:35] what you have been doing so you can ask
[54:37] for a summary of what you have done last
[54:39] week or what you have done last month
[54:42] and then you can have that for example,
[54:44] if you want you can actually create a
[54:45] skill
[54:46] put that skill somewhere inside of a
[54:49] folder or in your user profile and when
[54:51] you need it comes the moment to send
[54:53] that to your boss, you just run that
[54:55] skill and you have the thing ready. So
[54:57] it can use for those types of it can be
[54:59] used for those types of things as well.
[55:01] Or if you want something a bit more
[55:03] programmatic, something that feels like
[55:05] our day-to-day
[55:07] uh do you know when you have a a ton of
[55:09] files and you you want to extract
[55:10] information out of it, instead of
[55:12] writing a script, you can use the
[55:14] headless mode.
[55:15] Let's say that you have a ton of log
[55:16] files in the folder or your event viewer
[55:19] on Windows has a ton of errors and you
[55:21] want to understand what is there, you
[55:23] can run Cloud in the
[55:25] um
[55:25] as a script, right?
[55:27] And you don't expect Cloud to open but
[55:29] you'll find a the summary for you. You
[55:31] can even pipe the outcome to a given
[55:34] file if you need.
[55:37] Final one um
[55:39] is the following.
[55:40] You might be like me, but I I have that
[55:43] downloads folder in my machine, and
[55:45] that folder only works in one direction,
[55:48] that is growing and growing and growing.
[55:51] Until the day that I get the warning
[55:53] saying your disk is almost full, and I
[55:56] need to delete stuff. But I never know
[55:58] what I have there, and I'm I'm in fear
[55:59] of losing something that I will never
[56:01] need. That's That's the truth.
[56:04] But I don't want to delete things,
[56:05] because who knows?
[56:07] Uh but looking into something like
[56:10] this, it can be quite scary. I have
[56:13] Last week I had 1,626
[56:16] items over there. Uh so, how should I
[56:18] know what I should delete? It will take
[56:20] a ton of time to go through all of this.
[56:22] The worst part is is that some of them
[56:24] are actually folders, so there's even
[56:26] more items than those.
[56:28] So, what I thought was, "Hm, why not
[56:30] putting my
[56:31] Cloud Code doing that for me?"
[56:33] So, I open Cloud Code, and I prompted,
[56:36] "Let's go through this folder, the
[56:37] downloads, you can see it there, and
[56:39] organize it by type."
[56:41] Because by the end, I will see folders
[56:43] like installers, but I don't care about
[56:45] them.
[56:46] Code, for example, if it's important
[56:48] would be on my GitHub. So, those I know
[56:51] that I can delete them right away.
[56:54] For the other ones, now I have them
[56:56] organized, and I know what I'm looking
[56:57] for. So, you I end up with something
[57:00] like this.
[57:01] So, the code here is that you start
[57:05] about uh Cloud as much more than
[57:08] something that is capable of writing
[57:09] code, reviewing code, and fixing bugs.
[57:12] >> [snorts]
[57:12] >> Okay? It's actually an extremely
[57:14] powerful tool that you can use in your
[57:16] day-to-day to simplify your life.
[57:19] I hope you learned one or two things
[57:20] with me today. Uh if you apply one or
[57:23] two, I will be super happy, to be
[57:25] honest.
[57:26] But if you don't run any of those
[57:28] commands, at least run one that you can
[57:30] learn a lot with it, Because I learned
[57:33] more with that command than uh by
[57:35] reading LinkedIn posts, to be honest.
[57:38] That is the slash insights.
[57:40] If you run the slash insights, actually,
[57:42] you will get a report from Cloud
[57:45] explaining how do you use Cloud in your
[57:48] day-to-day.
[57:49] Explaining what you can do to improve
[57:51] your workflows. Explaining what usually
[57:54] is the the types of works that you do
[57:56] and types of skills that you could
[57:57] create. Something bigger than this,
[58:00] okay? If you go through this one, you
[58:02] will learn a lot about the things that
[58:04] you do in your day-to-day. And for sure,
[58:06] if you didn't learn something with me,
[58:08] you will learn something with Cloud. I
[58:10] hope you learned something with me
[58:11] today. To be honest, if there's
[58:13] something that I didn't mention and you
[58:15] actually love in Cloud Code, please come
[58:16] by and let me know. And if you have any
[58:18] question, I will be happy to answer it
[58:21] afterwards. Uh and I will see you
[58:22] around. Have a great conference. Thank
[58:25] you.
[58:26] >> [applause]