Anthropic Envoy Stensby Drops Coding as AI Shifts Software Bottleneck

10 tips to level up your ai-assisted coding - Aleksander Stensby - NDC AI 2026 — NDC Conferences

NDC Conferences

As frontier models eliminate the need for hand-written syntax, developer productivity shifts entirely to upstream requirement planning and autonomous verification loops that make rigid prompt scaffolding obsolete.

AI-assisted summary of 10 tips to level up your ai-assisted coding - Aleksander Stensby - NDC AI 2026 — original source. Check the original for full context.

Source published:

Key ideas

  • Frontier coding models degrade significantly when the context window fills beyond 70–80%, making proactive context resets and session summaries far more effective than relying on automatic compaction. (11:22)
  • Software development bottlenecks have inverted: AI generates code in parallel with near-zero marginal friction, leaving human intent definition upstream and code verification downstream as the true pacing constraints. (29:19)
  • Autonomous self-verification delivers the highest leverage in AI workflows by equipping agents with tools like Chrome MCP to catch runtime errors, test UIs, and iterate independently in the background. (36:43)
  • Engineering paradigms have rapidly shifted from prompt engineering to context engineering, harness engineering, and now loop engineering—where models receive target outcomes and stop conditions rather than sequential procedural commands. (58:17)

Detailed notes

## Background Published by NDC Conferences on YouTube on July 1, 2026, this talk features Aleksander Stensby speaking at NDC AI in Oslo, Norway. The session covers practical, developer-tested strategies for AI-assisted coding using tools like Cursor and Claude Code, focusing on context engineering, custom skills, Model Context Protocol (MCP), and evolving development workflows.

## TL;DR Aleksander Stensby outlines actionable techniques to transition from passive code generation to high-leverage agent collaboration, sharing that he has not written manual code since August of the prior year. He highlights the critical discipline of managing context window limits and compaction traps, emphasizing that output starts to degrade past 70–80% capacity. Developers are encouraged to build portable skills, enforce deterministic guardrails via hooks rather than system prompts, and equip agents with browser and CLI tools to verify their own outputs. Ultimately, Stensby charts the evolution from prompt engineering to harness and loop engineering, demonstrating how parallel execution, subagents, and automated validation shift human effort toward upstream intent and downstream verification.

## Atmosphere & style The presentation carries the candid, fast-paced energy of an experienced practitioner who has fundamentally reinvented his own workflow. Aleksander speaks with deadpan humor, self-deprecating anecdotes, and intense enthusiasm, famously shaving 'Ask Claude' into his hair and joking about how remote-controlling coding agents almost strained his marriage. It feels like an insider masterclass delivered straight from the bleeding edge, combining practical terminal tips with provocative philosophical shifts about the future of software engineering.

## Bulletin - [11:22](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=682s) Frontier coding models degrade significantly when the context window fills beyond 70–80%, making proactive context resets and session summaries far more effective than relying on automatic compaction. - [29:19](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1759s) Software development bottlenecks have inverted: AI generates code in parallel with near-zero marginal friction, leaving human intent definition upstream and code verification downstream as the true pacing constraints. - [36:43](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2203s) Autonomous self-verification delivers the highest leverage in AI workflows by equipping agents with tools like Chrome MCP to catch runtime errors, test UIs, and iterate independently in the background. - [58:17](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=3497s) Engineering paradigms have rapidly shifted from prompt engineering to context engineering, harness engineering, and now loop engineering—where models receive target outcomes and stop conditions rather than sequential procedural commands.

## Key takeaways - [06:20](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=380s) Treating AI as an active pair programmer prevents cognitive atrophy, whereas passive acceptance risks dulling developer problem-solving skills over time. - [06:20](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=380s) Compound engineering requires turning every failure or debugging rabbit hole into a permanent lesson, custom skill, or rule so the agent never repeats the same mistake. - [11:22](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=682s) Context window performance deteriorates noticeably at 70–80% capacity regardless of total token size, necessitating proactive management and visual monitoring. - [14:55](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=895s) Scaffolding rules and complex configurations in files like CLAUDE.md risk holding back rapidly evolving frontier models; developers should routinely review, prune, or reset their instructions. - [19:49](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1189s) Skills represent an open, portable industry primitive that lets developers package reusable workflows, teach taste, and grant entirely new multimodal capabilities. - [26:36](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1596s) Plans should always be persisted into dedicated Markdown files to survive context clears and serve as an objective source of truth against which the AI verifies its finished output. - [33:12](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1992s) To break the habit of lazy rubber-stamping, developers can instruct agents to present architectural decisions and reviews as interactive HTML pages or local web interfaces. - [36:43](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2203s) Auditing daily terminal exits (to Slack, Jira, or documentation) reveals the exact MCP servers and plugins needed to make an agent truly autonomous. - [39:10](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2350s) Dual-agent evaluator architectures (like the /goal command) separate implementation from evaluation, ensuring the agent executing the work does not rubber-stamp its own results. - [44:14](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2654s) Spending $100–$200 monthly on premium API tokens is economically trivial compared to the hidden engineering cost of babysitting and fixing output from sub-tier models. - [46:37](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2797s) Subagents create isolated execution scopes that simulate infinite context, with nested hierarchies allowing deep parallel execution without polluting the primary session history. - [48:35](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2915s) Natural language instructions in system prompts cannot guarantee safety; deterministic event-driven hooks (like pre-tool-use scripts) are required to reliably prevent destructive commands. - [51:13](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=3073s) Analyzing session archives via commands like /insights surfaces friction patterns, common failures, and automated rule suggestions to fuel continuous compounding improvements. - [55:06](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=3306s) While MCP provides vital bridges for non-developers and external platforms, CLI tools remain leaner and more natural for developer-focused coding agents in daily terminal workflows. - [56:35](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=3395s) Embracing asynchronous, parallel workflows using Git worktrees and remote agent triggers removes the human engineer as the sequential bottleneck. - [01:00:27](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=3627s) AI assistants often default to complex human coding patterns like regex; reminding them that they are AI encourages them to solve problems via headless LLM calls instead.

## Detailed walkthrough ### [00:07](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=7s) Introduction and the Shift Away from Writing Code

Welcoming a packed room at NDC AI, Alex introduces himself with a striking opening line: “My name is Alex. I used to be a developer. And now Claude writes all my code.” While the session is billed as ten tips to level up AI-assisted coding, he warns the audience that boiling the practical insights down to just ten proved impossible, so the talk will cover considerably more ground. Alex’s background spans computer science, machine learning, and pattern recognition. After writing code for many years, he spent an entire decade running a fairly large company where he built solutions through engineering teams rather than writing the software himself.

He reflects that being away from the keyboard for ten years proved to be an unexpected advantage when generative AI emerged. Returning to software development during the early days of GPT—when AI coding was essentially sophisticated autocomplete and tab completion—he lacked rigid, old-school development habits and was open to re-evaluating workflows from scratch. Today, he runs Grid AI, an organization helping enterprises adopt artificial intelligence; in the past year alone, he delivered AI training for Norway’s sovereign wealth fund (the National Oil Fund), Norges Bank, and numerous other major institutions. For Alex, working across engineering and non-technical teams highlighted what he considers the ultimate promise of generative AI: democratizing problem-solving.

Turning to the audience, Alex takes a show of hands to see how many people still write code, how many leverage AI, and how many have experimented with Claude Code. Seeing a large number of hands, he shares a personal disclaimer: he serves as the official Anthropic ambassador in Norway and organizes the local Claude Code meetup. Although he is not on Anthropic's payroll, his access gives him direct insight into their product direction. He stresses that while he will frequently refer to "Claude" throughout the session, the principles apply across the board to any AI coding agent or tool harness. Personally, Alex reveals that he has not written a single line of code himself since August of the previous year, noting that the inflection point arrived with the release of the Claude Opus model.

- **Background:** Formal computer science, machine learning, and pattern recognition training, followed by a 10-year executive hiatus from coding. - **Current roles:** Founder of Grid AI; corporate trainer (including the Norwegian National Oil Fund and Norges Bank); Anthropic ambassador in Norway; organizer of the Oslo Claude Code meetup. - **Personal milestone:** Has not written a single line of code manually since August of the previous year.

---

[03:39](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=219s) Rapid Model Velocity and the Diamond Frontier Code Benchmark

To illustrate the blistering speed of progress, Alex points out that Anthropic released nine frontier models over the previous 12 months, including a major model dropped only the day before the presentation. With models continually advancing, benchmarks have repeatedly become obsolete. To evaluate top-tier coding performance, researchers turned to the newly established Diamond Frontier Code benchmark. While earlier frontiers were set just weeks prior—and OpenAI’s GPT-5.5 is visible near the benchmark’s baseline reference line—Anthropic’s latest frontier release demonstrated a massive leap in capability on the hardest coding problems.

Alex acknowledges that this top-end performance comes with increased inference costs, but historical trends over the past year indicate that costs reliably fall after an initial release period. The sudden model release even forced Alex to spend the previous night reviewing and revising his talk's slides to ensure his recommendations accounted for the latest capabilities. Looking ahead, Alex offers a perspective on the future of development harnesses: “To be honest with you, and this is maybe a bit controversial, um but I think over time these models uh don't show sign of plateauing yet... And I believe that the need for harnesses um will sort of uh become less and less.” While current developer tooling and harnesses (like Cursor or Claude Code) remain essential today, raw model improvements may eventually make the choice of harness secondary.

```mermaid flowchart TD accTitle: Model Evolution vs Harness Necessity accDescr: Diagram illustrating how rapid model capability growth outpaces and eventually minimizes the need for complex agent harnesses.

subgraph Evolution["Model Evolution"] M1["Legacy Benchmarks (Obsolete)"] M2["Diamond Frontier Code Benchmark"] M3["Frontier Models (9 drops in 12 months)"] M1 --> M2 --> M3 end

subgraph Impact["Workflow Impact"] H1["Complex Tooling & Harnesses Required Today"] H2["Raw Model Reasoning Scales Up"] H3["Harness Layer Thins Out Over Time"] H1 --> H2 --> H3 end

M3 -.->|"Drives shift"| H2 ```

---

[06:20](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=380s) Tip 0: Pair Programming Mindset, Compound Engineering, and Asking Claude

Before diving into the numbered list, Alex outlines "Tip 0," which centers entirely on human psychology and collaboration. When developers adopt AI, they face a critical fork in the road: they can treat it lazily by throwing prompts at the model and blindly accepting whatever code comes back, or they can actively pair-program with it. Alex issues a blunt warning about passive usage: “And I think we if we do that, we risk maybe becoming more stupid over time. Uh but if we choose to actively collaborate with the AI, I think we can become even better versions of ourselves and not just become passive sort of takers of AI.”

A cornerstone of his workflow is *compound engineering*, an idea popularized by the company Every: - **Core ambition:** The AI agent must learn continuously alongside the developer through every session. - **Error prevention:** If the agent falls into an implementation rabbit hole or commits an error, that specific failure must never recur. - **Compounding interest:** Referred to in Norwegian as the *rentes rente-effekt*, where every fix, architectural guideline, and learned pattern compounds into a smarter agent over time.

Alex shares an anecdote featuring Boris Cherny, the creator of Claude Code, who attended the Oslo meetup. Whenever Alex asked Boris speculative questions about whether Claude could handle a complex task or when a specific feature would be supported, Boris repeatedly gave the same deadpan response: “Yeah, well, you can just ask Claude to do that. It can do that.” Alex realized that experienced adult engineers often suffer from rigid, ingrained mental models of what software tools can and cannot do, whereas children naturally ask why something isn't possible. Because frontier capabilities evolve every few months, developers must constantly recalibrate their assumptions. Alex even shaved "Ask Claude" into the back of his hair as a reminder to bypass habitual hesitation and simply prompt the tool first.

---

[10:08](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=608s) Tip 1: Context is King — Managing the Finite Glass

Moving into the core framework, Alex introduces his first primary category: "Context is king." Context is the single most critical lever under developer control and determines the quality of the model’s entire output. Because context is both vital and strictly limited, developers must act as stewards of the model's token allocation, ensuring the AI receives only the highest-impact tokens.

To explain the dynamics of the context window, Alex uses the visual metaphor of a water glass. The glass represents the strict, finite size of the context window. The moment a new agent session begins, the glass is already partially filled before the user types a single word of instruction. Baseline elements poured immediately into the glass include: 1. The harness’s underlying system prompt. 2. Global context files (such as `CLAUDE.md` or `agent.md`). 3. Tool declarations from Model Context Protocol (MCP) servers (including tool names and full function schemas/descriptions). 4. Configured custom skills (specifically their registered names and trigger descriptions).

Once those structural foundations are loaded, every subsequent prompt, user query, agent response, and raw tool execution output rapidly consumes the remaining space in the glass. Optimizing and preserving that remaining capacity is the developer's primary operational challenge.

[11:22](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=682s) Context Window Dynamics and Compaction Traps

Tool calls and internal reasoning cycles consume context rapidly. Aleksander Stensby notes that although the standard context "glass" hovered around 200,000 tokens for roughly a year to a year and a half, context windows expanded significantly to 1,000,000 tokens a few months prior. However, regardless of the physical size of this window, degradation follows a clear pattern:

> “irregardless of the size of the glass, what we have seen is that the results they start to deteriorate when we approach somewhere around 70-80% of the glass.”

Once the context window fills up, modern agent harnesses automatically trigger auto-compaction to compress the contents and allow the session to proceed gracefully. Stensby warns against letting this happen unchecked:

> “And we've seen that if we if we approach full glass, the results starts to deteriorate. So the key tip for you is to keep an eye on your context.”

To manage this, developers must actively track their context usage. In Claude Code, running `/statusline` allows the user to instruct Claude to display a visual battery indicator (e.g., in green) representing remaining context capacity. In Cursor, developers can configure default settings to show usage summaries or run `/context` to inspect exactly what files or messages are filling the window. Drawing on a point raised by Mats in the preceding talk, Stensby emphasizes that developers should keep heavy operations outside of LLM inference: programmatic CLI tools, scripts, or database queries should extract and pre-process data deterministically so that the model receives only refined context rather than entire raw datasets.

If auto-compaction becomes unavoidable, developers should actively steer it by invoking `/compact` with explicit instructions—for example, directing the agent to discard past debugging attempts while retaining key architectural decisions. Stensby's own preferred workflow bypasses auto-compaction entirely: he utilizes custom skills to say *"let's continue later,"* prompting Claude to summarize the current session into a markdown file. He then runs `/reset` or `/clear` to start a clean session and commands Claude to *"continue work,"* which reloads the summarized progress file into a fresh context window.

```mermaid flowchart TD accTitle: Context Degradation and Compaction Strategies accDescr: Diagram illustrating token consumption leading to 70-80% capacity degradation, followed by manual or guided context resets.

subgraph Glass["Context Window (Token Budget)"] A["Active Context: System Rules, Tools & Messages"] --> B["70% - 80% Threshold: Output Deteriorates"] B --> C["100% Full: Uncontrolled Auto-Compaction"] end

subgraph Solutions["Proactive Context Management"] B -.->|"Preferred"| D["Manual Session Export: Save to markdown & /reset"] B -.->|"Alternative"| E["Guided Compaction: /compact with explicit rules"] D --> F["Fresh Session Context Window"] E --> F end ```

---

[14:55](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=895s) Rule Management: Scaffolding vs. Model Capabilities

Instruction rules—placed in files like `agent.md` or `CLAUDE.md`—serve as the first layer of defense to guide agent behavior. Stensby shares a cross-tool interoperability trick: one can reference `@agents.md` inside `CLAUDE.md`, or vice versa, ensuring multiple harnesses consume the exact same rules without duplicating content.

However, files enter context differently: - `CLAUDE.md` and tool definitions are automatically loaded into the context glass at the start of every session or after every context reset. - Skill definitions are loaded into the window only at session startup. If the context auto-compacts, skill definitions do not re-enter the context window unless they were specifically invoked earlier in that session—a silent behavior change that frequently catches developers off guard.

Memory follows a similar principle. Beyond transient context, modern harnesses include persistent memory (such as `memory.md` in Claude Code, which lives in global settings or at the project level). Users can inspect and manipulate memory directly using `/memory` or by issuing prompts like *"What do you know about me?"*, *"Remember this"*, or *"Forget this"*.

Stensby illustrates rules and harness configurations using the metaphor of construction scaffolding. Scaffolding is built to prop up models and compensate for their current weaknesses. Yet developers often cling to their complex rule configurations even as underlying models rapidly improve:

> “And today of all days, after what happened and what came out yesterday I just wanted you to think about this and have a have a view on this because what happens is that the scaffolding we put in place risk holding back the models.”

Over-specifying procedural steps (such as forcing a rigid sequence of actions) can prevent newer models from solving problems more effectively. Stensby advises developers to periodically delete their `CLAUDE.md` file to benchmark baseline performance on raw tasks, or at minimum, feed the rule file back to the model and ask: *"You now have superpowers. What would you change here? What could hold you back? What should we remove?"*

---

[19:49](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1189s) The Power of Skills in 2026

When asked what developers should invest in learning for 2026, Stensby highlights skills as the single most important primitive. While coding harnesses fluctuate in popularity, skills represent an open, portable industry standard that transfers across tools.

> “Those of you didn't raise your hand, you have one job. Start using skills. Skills is portable. It's something that the entire industry is one of those rare moments in our world where someone comes up with a stupid simple yet brilliant idea and then the rest says, 'That's actually stupid simple and brilliant. We're all going to support it.'”

At its core, a skill requires nothing more than a folder containing a `skill.md` markdown file. Stensby divides skills into two functional categories: 1. **Taste, Preferences, and Workflows:** Teaching the model personal coding standards, project patterns, or team procedures. 2. **New Capabilities:** Granting the model functionality outside its native modality. For example, while Claude cannot natively generate images or audio, equipping it with skills that call APIs (like the Nano Banana API for images or ElevenLabs for voice and podcast generation) unlocks those behaviors.

For advanced developers, skills offer programmatic composition. A skill folder can bundle prompt templates, external references, and hierarchical sub-skills to manage token usage. Crucially, embedding executable scripts inside skills allows developers to enforce deterministic, repeatable execution patterns onto inherently non-deterministic LLMs.

[22:27](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1347s) Crafting and Automating Custom Skills

Controlling how and when skills are triggered is critical when designing automated workflows. In the skill file's YAML front matter, settings can alter default invocation behaviors. If a developer wants to retain full manual control and prevent the model from executing a skill autonomously, they can set `disable-model-invocation: true`. Conversely, setting `user-invokable: false` hides the skill from slash-command menus, reserving it exclusively for autonomous invocation by the model. As Aleksander Stensby remarks about the API design: “For some reason they have this reverse logic in how they uh create their settings.”

Rather than writing skill definitions from scratch, developers should delegate skill generation directly to Claude based on accomplished tasks. The ideal time to build a reusable skill is right after completing a piece of work through iterative prompting and refining: “So give feedback, ask your agent to do something, give feedback, and get it to the point where you're happy, and then instead of celebrating, you say, 'Now let's turn this into a repeatable skill.'” Stensby's personal heuristic is straightforward: “My rule of thumb is if I do something more than once, it probably deserves to become a skill.” These skills, along with the project's root `CLAUDE.md` or `AGENTS.md` configuration files, should be checked into version control to establish shared team knowledge, leaving personal workflow overrides to global or local configuration files.

Modern skills offer parity with traditional slash commands while introducing richer functionality. Skills can accept arguments, invoke or reference other skills, and be chained together sequentially. An advanced capability available in skills and sub-agents is dynamic context injection: by prefixing a bash command with an exclamation mark (`!`), the environment executes that shell command as a pre-processing step outside of model inference. The resulting terminal output is injected directly into the skill's prompt context before execution begins.

- Use `disable-model-invocation: true` to prevent automatic triggering by the model. - Use `user-invokable: false` to make skills model-only rather than slash commands. - Dynamic context injection uses `!<bash command>` to execute shell tasks before inference and feed raw command output into the skill context.

[25:10](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1510s) The Skill Creator and Supply-Chain Safety

While skill repositories such as `skills.sh` offer thousands of pre-made templates, Stensby strongly cautions against indiscriminately downloading third-party skills. External scripts pose real attack vectors and frequently suffer from poor quality. He stresses: “My recommendation is the best skills are the ones you build yourself together with your AI.” If an interesting skill is discovered online, developers should bring its core concept to their AI assistant and ask it to write a clean, safe implementation inspired by that reference.

For crafting reliable skills, developers should rely on Anthropic's official `skill-creator` (while ChatGPT provides an integrated alternative). Anthropic's implementation includes an integrated evaluation framework:

```mermaid flowchart TD accTitle: Skill Creator Self-Improvement Loop accDescr: Iterative flow of building, evaluating, and refining skills using the Anthropic skill creator. A["Draft or Existing Skill"] --> B["Run /skill-creator"] B --> C["Generate Eval Test Suite"] C --> D["Execute Evals & Inspect Results"] D --> E{"Passes Criteria?"} E -- "Needs Refinement" --> F["Automated Skill Optimization"] F --> C E -- "Success" --> G["Production-Ready Skill"] ```

When invoking `/skill-creator` to improve an existing skill, the tool constructs an evaluation suite, tests the skill against various scenarios, displays the benchmarks, and applies automated refinements in a tight self-improvement feedback loop.

[26:36](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1596s) Plan Mode, Context Persistence, and Verifiable Specs

Stensby emphasizes that planning is the single highest-leverage area for human developer time: “Always start with a plan.” As engineers write less raw code by hand and develop confidence in generative models, human effort must shift toward articulating exact requirements. Modern coding environments like Claude Code and Cursor offer dedicated plan modes. Beyond scaffolding future work, plan mode enforces a read-only safety sandbox that lets developers explore unfamiliar codebases, investigate bugs, and conduct architectural reconnaissance without risking unintended file edits.

Plans should always be explicitly persisted into a dedicated Markdown file or progress document rather than left as ephemeral chat state or auto-generated temporary scratchpads. Persisting the plan accomplishes two vital goals: 1. **Context Survival**: It preserves architectural intent across context clears, token limits, and session refreshes. 2. **Autonomous Verification**: It gives the AI an explicit source of truth to validate its finished code against, eliminating the need for constant manual line-by-line inspection.

While software teams constantly cycle through popular specification frameworks and kits (like Spec and Spec Kit), Stensby urges developers to keep their approach lightweight. The exact schema matters far less than having a structured document that describes the goal and allows the model to measure its finished implementation against that baseline.

[29:19](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1759s) Chasing Bottlenecks: Rethinking Software Processes

Software development processes, ceremonies, and tooling were historically designed around a single constraint: human code writing was an expensive, scarce resource. Now that AI can generate functional code at high speed—often matching or exceeding human capability—the primary bottleneck has broken and shifted outward in both directions.

```mermaid flowchart LR accTitle: Shifting Bottlenecks in AI-Assisted Development accDescr: Historical coding bottleneck compared to the modern dual human bottlenecks of intent and verification. subgraph Past["Legacy Paradigm"] direction TB P1["Planning"] --> P2["Coding: The Core Bottleneck"] P2 --> P3["Testing & Review"] end subgraph Present["AI-Assisted Paradigm"] direction TB A1["Upstream Bottleneck:<br/>Intent, Taste, and Scoping"] --> A2["AI Code Generation:<br/>Parallel & Unconstrained"] A2 --> A3["Downstream Bottleneck:<br/>Verification & Validation"] end ```

The upstream bottleneck is now the human ability to supply the AI with structured jobs, clear intent, and domain taste fast enough to satisfy parallel agents. The downstream bottleneck is validation—thoroughly testing, reviewing, and verifying that the generated artifacts behave correctly.

Because teams are tackling modern AI generation using legacy processes, Stensby challenges engineering organizations to rethink basic assumptions: - **Code Reviews**: Re-evaluate why PR reviews exist in their current manual format. - **Sprint Planning**: Question whether sprint cadences make sense when development cycles move asynchronously. - **Retrospectives**: Re-architect how teams assess progress and team friction.

Stensby notes that this phenomenon—which he terms “chasing bottlenecks”—is not unique to software engineering; developers are simply at the forefront of a systemic shift that will soon disrupt all knowledge work. As developers navigate this shift, remaining actively engaged during upstream planning becomes essential, even as managing dense, lengthy Markdown specifications presents new cognitive challenges.

[33:12](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1992s) Breaking the "Lazy Approval" Habit with Interactive HTML Formats

Aleksander Stensby warns of a common trap developers fall into when collaborating with AI agents: passively skimming text output and saying, "Yeah, that looks good. Let's just go on and continue, right?" He stresses how perilous this tendency is, noting that it leads directly to an all-hands-off, disengaged mindset. “Because then we are now sort of all hands-off, and we are sort of approaching this lazy way of working, right? I I I'm afraid of that.”

To keep humans actively engaged in the feedback loop, Aleksander points to an emerging technique: instructing the AI to output plans or reviews as interactive HTML pages instead of raw Markdown text. By asking the assistant to present information in a styled, visually appealing format, developers can digest choices far more naturally. Once baked into a reusable agent "skill," this formatting happens automatically without needing repeated instructions every session, turning what would have been mindless rubber-stamping into an engaging visual review.

```mermaid flowchart TD accTitle: Interactive Visual Review Feedback Loop accDescr: Moving from passive markdown review to interactive HTML-based feedback for AI agents.

subgraph Passive["Passive Trap"] A["Agent outputs raw Markdown"] --> B["Developer skims text"] B --> C["Passive approval: 'Looks good'"] end

subgraph Active["Engaging Workflow"] D["Agent outputs styled, interactive HTML"] --> E["Developer visualizes choices & interacts"] E --> F["Actionable feedback sent back to Agent"] end ```

[34:21](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2061s) Superpowers: End-to-End Development Skills and Web-Based Brainstorming

Expanding beyond single-file prompts, Aleksander highlights "superpowers"—a curated collection of skills designed to support every phase of the software development lifecycle. While the suite is remarkably comprehensive, Aleksander offers an important caveat: running the entire sequence end-to-end consumes an enormous number of tokens and easily becomes overkill for smaller programming jobs. His practical solution is to ask Claude to modify the skill definitions so the complete sequence is not automatically model-invocable, keeping the human developer firmly in control of when to fire off the full pipeline.

Among these tools, Aleksander highlights the brainstorming skill, describing it as "plan mode on steroids." During an update, the tool introduced a game-changing capability where the agent spins up a local web server to present options. Rather than listing architectural trade-offs in bullet points, the agent presents distinct UI mockups or system designs in a local browser with clickable options (such as option one, two, or three). Clicking a selection instantly relays the developer's choice and feedback directly back to Claude.

- **Superpowers skillset:** Covers planning, architecture, implementation, and review, but runs heavy on tokens if left fully autonomous. - **Selective invocation:** Best practice is to restrict automatic triggering so the human chooses when deep planning runs. - **Interactive web server:** Claude can spin up a local web server during brainstorming sessions to let the user select architectural paths via browser clicks.

[36:43](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2203s) Equipping Agents with Developer Tools to Verify Their Own Work

When addressing productivity bottlenecks, Aleksander urges developers to evaluate the exact tools they rely on throughout their workday. If a developer expects an AI agent to execute tasks autonomously, the agent must be equipped with the identical tools, permissions, and context that the human developer uses. He suggests a simple daily diagnostic: spend a morning working entirely within the terminal, and make a note of every single moment you are forced to switch away—whether jumping into Slack, searching documentation online, or updating a Jira ticket. Every distraction points to an MCP (Model Context Protocol) integration or tool plugin that your AI agent is missing.

Aleksander argues that enabling an AI to verify its own code before reporting completion provides the single highest leverage point in modern engineering. Instead of waiting for the AI to finish, manually starting a local development server, launching Chrome, clicking through UI flows, and digging into browser developer tools for console errors, developers should provide browser automation tools directly to the agent. Leveraging tools like the Chrome MCP plugin or built-in browsers found in tools like Cursor and Claude Desktop, the model can navigate web pages, catch runtime errors, and iterate until the feature actually works. While automated browser loops are somewhat slow, Aleksander considers this irrelevant since the agent executes its checks quietly in the background while the engineer moves on to other tasks.

- **The terminal audit exercise:** Log every time you leave the terminal (e.g., Slack, documentation lookups, Jira) to uncover missing agent capabilities. - **Self-verification leverage:** “Maybe the single highest leverage that we can that we can do right now is to give AI a way to verify its own work.” - **Background execution:** Slower agent browser loops are entirely acceptable because they run concurrently without blocking developer focus.

[39:10](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2350s) Visual DOM Feedback and the Shift to Outcome-Driven Engineering

Aleksander introduces practical visual annotation mechanisms for web development, specifically highlighting a utility called **agentation**. Designed for frameworks like Next.js, it injects a floating toolbar onto the running application. Developers can draw annotations, highlight specific elements, and click components directly in the browser. The tool automatically resolves and captures the underlying DOM paths and context, letting the developer copy an enriched prompt straight into their coding agent. Aleksander uses a similar approach in the Claude Desktop app, relying on built-in DOM-specific annotation to visually critique frontend work and feed corrections back into the model.

```mermaid flowchart LR accTitle: Dual-Agent Verification Loop accDescr: How slash goal uses a worker agent and an independent evaluator agent to meet objectives.

subgraph GoalExecution["Goal Execution Loop"] G["Developer defines objective via /goal"] --> W["Worker Agent executes plan"] W --> E{"Evaluator Agent checks outcome"} E -- "Criteria not met" --> W E -- "Verified" --> D["Task Completed"] end ```

Connecting this to the release of newer frontier models and tools like Claude Code and Codex, Aleksander quotes Claude Code engineer Boris Cherny (referencing Tariq's post): “We used to verify that Claude did the work right. Now, we verify that it's doing the right work.” The developer's primary role is transitioning from micro-managing code output to framing clear outcomes and building robust guardrails. This philosophy is embodied in features like the `/goal` command found in Codex and Claude Code. Instead of dictating step-by-step instructions, developers provide target outcomes and constraints, leaving execution up to a multi-agent harness:

- **Multi-agent validation:** The model executing the task never evaluates its own completion; a separate evaluator agent inspects the final output against the objective. - **Rejection loop:** If the evaluator disagrees that the goal is reached, the loop restarts and the worker agent continues refining. - **The "token-rich" reality:** Complex autonomous loops and dual-agent evaluators are token-intensive, functioning best when developers have ample token budgets to achieve high-quality results.

[044:14] Token Economics and Debugging Consumption with `/usage`

Aleksander addresses the cost realities of running state-of-the-art models. While top-tier intelligence can seem expensive, he argues that the hidden tax of developer frustration and manual steering is far higher:

> “The time that I have to spend fixing, correcting, guiding with a lesser model or a mediocre model or a sub top model, I believe we can essentially defend the additional cost of running a superior model.”

He pokes fun at complaints from developers attempting to build complex engineering workflows while constrained to a standard $20/month subscription tier. If saving time allows someone to operate as a "10x version" of themselves, spending $100 or $200 a month on API tokens easily pays for itself.

For those needing to monitor and rein in runaway token costs, he points to the newly added `/usage` command. While recently integrated into the SDK and expected to land in desktop clients shortly, running `/usage` directly in the terminal uncovers detailed metrics. Below the basic session data, it provides an itemized summary of token consumption down to the specific skills and plugins causing spikes. Stensby jokes that this view often catches developers red-handed when they realize a flashy community plugin—like the "superpowers plugin that Alex recommended"—is quietly draining their entire token quota in the background.

- **Developer ROI vs. Subscriptions:** The friction of babysitting a weaker model costs far more than the $100–$200 monthly bill for premium intelligence. - **Diagnostics with `/usage`:** Terminal command revealing granular session data, breaking down token usage by individual tool calls, context items, and custom skills.

---

[046:37] Subagents: Engineering Infinite Context and Nesting

Stensby introduces subagents as the primary architectural pattern to circumvent token limits and simulate effectively infinite context windows. Because every subagent initializes with its own isolated context space, work can be offloaded without polluting the primary agent's history. Anthropic had just rolled out nested subagent execution the night before, enabling subagents to spawn their own child subagents up to a cap of five levels deep.

He also explains context management when launching these workers. By default, child agents begin with an "empty glass," receiving only the explicit instructions provided in the caller's prompt. However, when a task requires broad historical knowledge, developers can pass the `context: fork` parameter in the subagent definition to duplicate the entire current parent context into the child:

```mermaid flowchart TD accTitle: Subagent Context Architecture and Nesting accDescr: Diagram illustrating parent agents spawning nested subagents with isolated or forked contexts.

subgraph ParentScope["Main Agent Context"] A["Main Agent"] end

subgraph ForkedExecution["Context: Fork (Full History)"] B["Subagent (Forked)"] end

subgraph IsolatedExecution["Isolated Context (Empty Glass)"] C["Subagent Level 1"] D["Subagent Level 2 (Nested up to 5 Deep)"] end

A -->|"context: fork"| B A -->|"default prompt only"| C C -->|"nested dispatch"| D ```

Despite previously spending hours handcrafting rigid subagent definitions, Stensby notes that recent models (specifically post-Claude 3.5 Sonnet / Claude 3 Opus) are increasingly capable of orchestrating and provisioning task-specific agents on the fly. He warns that maintaining rigid, hand-tuned agent profiles created months prior often turns into stale boilerplate that holds back the model's emergent problem-solving abilities.

- **Infinite Context Mechanism:** Offloading execution subtrees to ephemeral subagents ensures the root agent's context window stays lean. - **Hierarchical Nesting:** Tools now permit agent hierarchies up to five levels deep. - **`context: fork`:** A configuration flag allowing subagents to inherit the full conversational state when required, instead of starting from scratch.

---

[048:35] Deterministic Guardrails and Automation with Hooks

Turning to control mechanisms, Aleksander contrasts soft system prompts with programmatic hooks. While a project's `CLAUDE.md` can instruct the model to "never, ever" run a destructive action, natural language instructions do not offer true safety guarantees:

> “Because even though we can say never ever ever do this, this, this in your Claude MD file, that is not a guardrail.”

To obtain absolute guarantees, developers must implement event-driven hooks outside the inference loop. Using events like `pre-tool-use` combined with regex matchers or newly supported `if` clauses, developers can execute deterministic scripts that actively intercept tool payloads and halt execution—preventing catastrophic operations like an unintended `rm -rf`.

Beyond safety boundaries, hooks serve as automation engines. Teams can attach scripts to file changes or pre-commit events to automatically run code formatters, execute linters, or run test suites. Stensby highlights that even popular autonomous loops like the community-named "Ralph Wiggum" loop—which keeps an agent looping until an objective is met—can be implemented using a trivial hook that catches the `stop` event and returns an instruction to keep going.

- **Non-Deterministic vs. Hard Guardrails:** Prompt rules in markdown are suggestions; hooks are deterministic software interceptors. - **`pre-tool-use` Interception:** Programmatic scripts inspect upcoming shell commands or file edits to block hazardous operations before execution. - **Workflow Automation:** Hooks cleanly orchestrate automated tasks like running a linter after every file modification or formatting code prior to git commits.

---

[051:13] Compound Engineering and the `/insights` Command

Aleksander emphasizes "compound engineering"—the operational philosophy that development teams must treat AI workflows as evolving systems that learn from friction and mistake cycles. Instead of manually solving a difficult edge case and moving on, developers should end painful debugging sessions by instructing the agent to reflect on its missteps, extract the resolution, and encode the lesson into repository skills or local markdown guides so the agent never repeats the mistake.

To illustrate how to operationalize this, he polls the audience on who has used `/insights`, noting the sparse show of hands:

> “And then the `/insight` is essentially just a skill, which says something like, analyze all of our sessions over the past 30 days and look for patterns, draw out key learnings, where did we go wrong, where did we fail, what did we do well, and then it puts it all together into an HTML report.”

All modern coding agent harnesses preserve historical session traces on disk (the underlying data that powers features like `/resume`). The `/insights` pattern analyzes this archive to surface usage trends, quantify common failure modes, identify forgotten features, and automatically generate copy-pasteable snippets—such as new hooks or tailored rules for `CLAUDE.md` designed to prevent specific recurring blunders. Stensby urges developers to run this process regularly regardless of their specific tooling, concluding that compounding gains come directly from analyzing real-world interaction histories.

[55:06](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=3306s) Memory Management, Hooks, and Choosing Between CLI and MCP

Aleksander Stensby emphasizes that developers must take an active role in maintaining their AI coding assistant's memory, rules, and reusable skills rather than assuming the assistant will handle it automatically. Capturing recurring patterns into defined skills and setting up enforcement mechanisms ensures reliable behavior across coding sessions. Stensby summarizes the core mindset: “If we want to enforce it, we can definitely use hooks to ensure that it happens all the time, uh not leaving it up to uh hoping that the AI will will do it.” Adopting a continuous habit of prompting the AI to learn from its errors compounds into significantly better development results over time.

Turning to tool integration, Stensby addresses the ongoing industry debate comparing Model Context Protocol (MCP) and Command Line Interface (CLI) utilities. While some claim that MCP is obsolete and CLI tools have won, Stensby disagrees with that absolute view, though he acknowledges his personal preference as an individual developer: “A lot of people say MCP is dead and CLI is and I I I don't agree, but I do as an individual contributor developer lean towards CLI tools when it's for me.” Coding agents naturally excel at issuing bash commands and reading terminal documentation, making CLI tools far lighter on context window consumption in daily workflows. However, MCP remains indispensable as an ecosystem bridge, enabling teams to distribute tool-use capabilities to non-engineers and integrate external platforms that lack full agentic coding harnesses.

- Maintain an active habit of capturing patterns into skills and asking the AI to learn from mistakes. - Use automated hooks rather than passive hope to guarantee rules run consistently. - CLI tools consume less context window space and leverage coding models' native fluency with bash. - MCP remains crucial for sharing capabilities with non-developers and systems without terminal harnesses.

---

[56:35](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=3395s) Parallel Workflows, Worktrees, and Asynchronous Task Hand-offs

Under tip number nine, Stensby urges developers to move beyond sequential interactions and embrace parallel execution once they trust the assistant's code generation. When developers wait idle for an agent to finish writing a single feature, coffee consumption reaches its natural limit, turning the human into the system bottleneck. To make the point, Stensby jokes about how consuming this workflow can become: “And and and and this can be very addictive. Uh and it can ruin marriages. Uh I saved mine, but but I would have to say I was a bit close when Claude Code launched remote control.” With remote capabilities running on his phone, he found himself nodding along to conversations while surreptitiously queuing tasks to keep his background agents occupied.

Developers can start scaling their execution through practical tools like Git worktrees, which provide isolated repository checkouts that let multiple agent sessions edit code simultaneously without file conflicts. Stensby shares his evening habit of offloading work asynchronously via GitHub Issues integrated with Claude Code. Standing in his bathroom before bed, he quickly comments on several issues with `@Claude fix this` prompts to see how many PRs the model can open before he finishes brushing his teeth—a record that currently stands at six completed tasks. Features like Claude Code's remote control allow engineers to step away from the desk, touch grass, and breathe fresh air while agents tackle assigned tickets and ask for human review only when blocked.

```mermaid flowchart TD accTitle: Parallel Agent Workflow accDescr: Diagram showing how a developer assigns multiple parallel tasks using Git worktrees, remote control, and GitHub issues.

subgraph Developer["Developer Interface"] A["Developer (Bottleneck)"] B["GitHub Issues ('@Claude fix this')"] C["Remote Control (Mobile)"] end

subgraph Isolation["Isolation Layer"] D["Git Worktree 1"] E["Git Worktree 2"] F["Git Worktree 3"] end

subgraph Execution["Autonomous Agents"] G["Agent Session 1"] H["Agent Session 2"] I["Agent Session 3"] end

A --> B A --> C B --> D B --> E B --> F D --> G E --> H F --> I ```

---

[58:17](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=3497s) The Evolution of Engineering: From Prompts to Loops

Stensby charts the historical progression of working with generative models, framing it as a direct consequence of expanding model capabilities and context windows. Early paradigms relied on prompt engineering to squeeze maximum accuracy out of small-context models performing one-shot tasks. As windows expanded and tools like MCP arrived, developers shifted to context engineering to curate rich multi-task environments. This subsequently matured into harness engineering to sustain structured, long-running agent workflows. Today, the conversation has pivoted toward "loop engineering"—a phrase popularized after Peter Steinberger, Boris, and Addy Osmani highlighted workflows where top-level Claude instances write prompts to drive and coordinate child Claude instances.

```mermaid flowchart LR accTitle: Evolution of LLM Development Paradigms accDescr: Timeline flowchart tracing prompt engineering to context engineering, harness engineering, and loop engineering.

A["Prompt Engineering<br/>(One-shot tasks, small context)"] --> B["Context Engineering<br/>(Multi-tasking, MCP tools)"] B --> C["Harness Engineering<br/>(Large loops, long-running tasks)"] C --> D["Loop Engineering<br/>(Target goals, stop conditions, multi-agent)"] ```

Stensby clarifies that despite the buzzword, the core mechanic of loop engineering is straightforward: “I think it's really uh about uh using the constructs we now have available and the capabilities of the models to essentially, instead of prompting, we give it a stop condition, we give it a goal, we give it a target, and then we give it the means to work potentially at large scale.” Rather than getting lost in the hype of thousands of parallel agents and massive token bills, developers can implement effective loops with a simple foundation: persistent task state across sessions. Stored to-do lists or issue queues allow scheduled jobs to wake up nightly, check whether pending work remains, and drive tasks to completion against a verifiable stop condition.

- **Prompt Engineering**: Focused on one-shot instructions constrained by small context windows. - **Context Engineering**: Curating dynamic context, files, and MCP tool definitions across tasks. - **Harness Engineering**: Designing scalable runtime scaffolding for extended agent sessions. - **Loop Engineering**: Defining clear goals, resources, and programmatic termination checks across iterative cycles.

---

[01:00:27](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=3627s) Ultra Code, Reminding the Model It Is AI, and Closing Remarks

For developers looking to see advanced multi-agent execution in action, Stensby points to Ultra Code, a capability integrated into Claude Code. Ultra Code instructs Claude to generate custom runtime harnesses on top of itself, launching swarms of coordinated agents to crack complex, multi-stage problems. While Stensby cautions that this level of abstraction can burn an extraordinary number of tokens and is complete overkill for routine coding tasks, it demonstrates the outer boundary of self-orchestrating model workflows.

A recurring blind spot in AI coding assistants is their tendency to emulate traditional human engineering patterns. Because LLMs are trained on human code repositories, they default to conventional developer approaches—such as wrestling with dense, complex regular expressions—when faced with data-wrangling tasks. Stensby advises developers to nudge the assistant about its actual nature: “Remember to mention to Claude that it is Claude and that it can use Claude to solve problems.” When reminded that it is an AI, the model will realize it can run itself in headless mode, call an OpenAI API endpoint, or delegate sub-tasks like sentiment analysis directly to language models instead of writing convoluted procedural code. Wrapping up as his session time runs out, Stensby reminds the audience that keeping a human in the loop remains mandatory, though engineers should continuously streamline their validation pipelines so that verification requires minimal manual effort.

## Notable quotes > [39:10](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2350s) We used to verify that Claude did the work right. Now, we verify that it's doing the right work. — Boris Cherny

> [36:43](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2203s) Maybe the single highest leverage that we can that we can do right now is to give AI a way to verify its own work. — Aleksander Stensby

> [22:27](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1347s) My rule of thumb is if I do something more than once, it probably deserves to become a skill. — Aleksander Stensby

> [25:10](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=1510s) My recommendation is the best skills are the ones you build yourself together with your AI. — Aleksander Stensby

> [44:14](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=2654s) The time that I have to spend fixing, correcting, guiding with a lesser model or a mediocre model or a sub top model, I believe we can essentially defend the additional cost of running a superior model. — Aleksander Stensby

> [01:00:27](https://www.youtube.com/watch?v=K7dBRuSDWTw&t=3627s) Remember to mention to Claude that it is Claude and that it can use Claude to solve problems. — Aleksander Stensby

## Mentioned Aleksander Stensby, Anthropic, Boris Cherny, Claude, Claude Code, Claude Desktop, Claude Opus, Cursor, Diamond Frontier Code benchmark, ElevenLabs, Every, Figma, GitHub, GitHub Issues, Git worktrees, GPT-5.5, Grid AI, Model Context Protocol (MCP), Nano Banana API, NDC AI, Next.js, Norges Bank, Norwegian National Oil Fund, OpenAI, Playwright, Slack, Ultra Code

## 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

Follow our Social Media!

https://www.facebook.com/ndcconferences https://twitter.com/NDC_Conferences https://www.instagram.com/ndc_conferences/

#ai #claudecode

AI coding assistants are rapidly reshaping how developers write, debug, and ship software. Tools like Cursor and Claude Code can supercharge productivity — but only if you know how to use them effectively.

In this session, we’ll cut through the hype and focus on practical, developer-tested strategies for getting the most out of AI in your workflow.

You’ll learn how to master prompting and context engineering, make the most of long context windows, streamline debugging and testing, and integrate AI into your daily development practices without sacrificing code quality or security. We’ll also explore how emerging standards like Model Context Protocol (MCP) unlock new workflows by connecting your AI assistant directly to tools such as GitHub, Slack, Playwright or Figma — turning it from a code generator into a true development teammate.

Whether you’re new to AI-assisted coding or already experimenting with it daily, you’ll leave this talk with concrete ideas and techniques you can apply immediately to level up your development process.

[Source](https://www.youtube.com/watch?v=K7dBRuSDWTw)

Reading summary

Aleksander Stensby argues that as frontier AI models rapidly outgrow traditional programming, developer productivity hinges not on manual coding, but on proactive context curation, programmatic guardrails, and automated verification loops. Context Budgeting and Compaction Risks (10:08) Context is the primary determinant of model output quality, yet developers frequently mishandle its finite capacity. Regardless of whether a context window holds 200,000 or 1,000,000 tokens, Stensby notes that output quality consistently deteriorates once consumption reaches 70% to 80% of capacity. Baseline configurations—including system prompts, global context files like `CLAUDE.md`, Model Context Protocol (MCP) tool schemas, and registered skill definitions—prefill the context glass before any user prompt is executed. To prevent uncontrolled degradation, developers should actively monitor token usage via tools like `/statusline` or `/context` rather than relying on automatic compaction. When compaction occurs, registered skills are silently dropped from the window unless invoked earlier in that session. Stensby recommends running data extraction deterministically via external CLI tools, guiding manual `/compact` commands with explicit architectural instructions, or exporting session summaries to markdown and resetting the window completely. Portable Skills and Scaffolding Depreciation (14:55) Stensby identifies skills as the single most critical, cross-tool primitive for developers in 2026. Defined in a simple directory containing a `skill.md` file, skills encode developer preferences and provide external capabilities, such as audio or image generation APIs. Skills can accept arguments, chain sub-skills, and execute pre-inference bash commands using dynamic context injection (`!<bash command>`) to feed command outputs directly into the prompt context. Stensby advises against blindly adopting untrusted third-party skill repositories, recommending Anthropic's official `/skill-creator` to generate and benchmark customized skills using automated evaluation loops. However, developers frequently allow outdated configurations to hold models back. Static instruction files, like `CLAUDE.md`, act as temporary construction scaffolding meant to cover model deficiencies. Because underlying reasoning models improve rapidly—reflected in benchmarks like the Diamond Frontier Code benchmark—procedural constraints can become counterproductive. Stensby advises teams to periodically benchmark raw model performance without scaffolding or prompt the model to identify rules that restrict its current capabilities. Shifting Bottlenecks from Coding to Verification (29:19) Because code generation is no longer the primary resource constraint, software engineering bottlenecks have split outward into upstream intent specification and downstream verification. Upstream, developers must invest time in plan mode to produce persisted markdown specifications, which survive context resets and serve as verifiable ground truth. To prevent passive 'lazy approval,' Stensby suggests prompting agents to present plans as interactive HTML mockups or local web applications rather than raw text. Downstream, verification becomes the highest-leverage human activity. Autonomous execution succeeds only when the agent has access to the same tools as the developer, such as terminal utilities and browser automation via Chrome MCP plugins to test runtime errors in the background. In advanced setups such as the `/goal` command, validation is separated from execution: a worker agent implements changes while an independent evaluator agent verifies the finished output against target criteria before closing the loop. Programmatic Guardrails and Scaled Loops Natural language instructions in markdown files cannot serve as absolute security boundaries. Stensby stresses that deterministic control requires event-driven hooks outside the inference loop. Event interceptors like `pre-tool-use` evaluate upcoming commands against programmatic rules or regex matchers, blocking destructive operations like `rm -rf` while automating formatting and linting tasks. To overcome token boundaries without polluting the main context, developers can spawn isolated subagents up to five levels deep, selectively using `context: fork` when the child agent strictly requires full historical context. These mechanisms culminate in 'loop engineering,' where developers establish persistent state—such as GitHub Issues or worktrees—and assign asynchronous tasks using remote control or background scripts. Rather than micromanaging code, developers define explicit goals, resources, and termination checks that drive agents to completion. While advanced agent swarms and multi-agent loops offer massive leverage, Stensby notes that they are token-intensive and can quickly become expensive overkill for routine tasks. Retaining human oversight remains mandatory, but engineering teams must evolve legacy ceremonies—like traditional code reviews and sprint planning—to keep pace with asynchronous, agent-driven workflows.

Source quotes

[39:10] Boris Cherny: We used to verify that Claude did the work right. Now, we verify that it's doing the right work. [36:43] Aleksander Stensby: Maybe the single highest leverage that we can that we can do right now is to give AI a way to verify its own work. [22:27] Aleksander Stensby: My rule of thumb is if I do something more than once, it probably deserves to become a skill. [25:10] Aleksander Stensby: My recommendation is the best skills are the ones you build yourself together with your AI. [44:14] Aleksander Stensby: The time that I have to spend fixing, correcting, guiding with a lesser model or a mediocre model or a sub top model, I believe we can essentially defend the additional cost of running a superior model. [60:27] Aleksander Stensby: Remember to mention to Claude that it is Claude and that it can use Claude to solve problems.

Original transcript

[0:07] Wow. [0:08] Packed room. [0:10] Welcome. [0:11] I think we'll kick off. [0:13] My name is Alex. I used to be a [0:15] developer. And now [0:17] Claude writes all my code. [0:20] Um, this talk is [0:23] supposed to be 10 tips [0:26] to level up your AI assisted coding. [0:29] But it's very difficult to boil it down [0:31] to 10. So there's going to be probably a [0:32] few more than 10. [0:34] Um, [0:35] it's a packed presentation. [0:38] So I'll keep it very short. [0:40] As I said, I'm Alex. Um, [0:43] I have a background in computer science. [0:46] Um, in machine learning and pattern [0:48] recognition. [0:50] And I [0:51] wrote code for many years. [0:53] And then I had 10 years where I did not [0:55] write code and I ran um, a fairly large [0:59] company. I worked with building [1:01] solutions, but I had a lot of people [1:02] that wrote the code. And I think it was [1:04] a bit of a an advantage for me when I [1:07] got back into coding. Um, [1:10] and I didn't have sort of my set ways of [1:12] doing things. And I came back [1:15] in the early days of GPT where we had [1:18] sort of sophisticated um, [1:21] auto complete. [1:22] Tab completions. [1:24] And I've been along for the ride ever [1:26] since. Today, I [1:28] run a small company called Grid AI. [1:31] We help a lot of organizations with um, [1:36] AI. [1:37] And uh, last year I did the [1:40] AI training for the National Oil Fund [1:43] and the Norwegian Bank and a lot of [1:45] other companies. [1:47] I work with a lot of developers, but I [1:48] also work with non-developers and [1:50] non-technical people. And [1:52] the greatest thing about generative AI [1:55] in my view is that we are democratizing [1:58] the ability to solve problems and I [2:00] really love it. [2:02] So, [2:03] how many of you [2:05] still write code? [2:08] Yeah, fair enough. [2:10] Those of you who [2:12] who still write code, do you use AI? [2:16] Good. [2:18] And how many of you [2:20] have used Claude Code? [2:22] So, a bit of a disclaimer, that's a lot. [2:24] That's a lot. I'm happy to see that. Bit [2:26] of a disclaimer, I am the Anthropic [2:29] ambassador in Norway. I run the Claude [2:32] Code meetup in Norway. I'm not paid by [2:34] Anthropic. They support the meetup and I [2:37] have access to them so they tell me a [2:39] lot of interesting things which I really [2:41] enjoy and I try to share as much as [2:42] possible. So, this talk is um [2:46] going to be [2:48] not specific to Claude Code but I might [2:51] say Claude a lot. But when I say it, it [2:54] roughly trans- lates to any [2:57] AI coding agent or harness. So, it's [2:59] sort of you can you can take my lessons [3:03] and apply them generally all of them. [3:05] There are a few things at the end of the [3:06] presentation which might still be [3:08] specific to Claude Code but yeah, try to [3:11] just translate whenever I say the word [3:13] Claude. Okay? [3:17] So, I think for me personally, I haven't [3:19] written a single line of code since [3:22] probably August last year. Um [3:26] and I think the the big shift sort of [3:28] came in [3:30] October last year when we got [3:33] the latest Opus model and then I think a [3:35] lot has obviously transpired since then. [3:39] Um in the past 12 months, Anthropic [3:44] I believe has dropped nine frontier [3:47] models in 12 months [3:50] including the one we got yesterday. [3:52] Um and it just shows that the pace is [3:55] incredible. Uh some of these are of [3:57] course incremental um [4:00] improvements to capabilities. Um and I [4:03] haven't had the chance I didn't stay up [4:05] all night last night. Did stay up a [4:06] little bit. So, I haven't really tried [4:08] to sort of fully see the capabilities, [4:11] but uh judging by benchmarks, which you [4:13] always have to obviously [4:15] um you know, take with a grain of salt. [4:17] Uh uh [4:18] it appears to be a significant leap. [4:21] Uh and on the hardest benchmarks, um [4:24] I think that's maybe the most [4:26] interesting thing where you look at this [4:28] fairly new benchmark because all other [4:31] benchmarks started to become obsolete. [4:33] Um this one is called the Diamond [4:36] Frontier Code benchmark, where the [4:38] previous state of the art well, the [4:40] previous state of the art was launched 2 [4:42] weeks ago. So, uh and that was also from [4:44] Anthropic. But, uh if you if you compare [4:46] it to um to GPT-5.5, you see uh it's not [4:51] named here, but 5.5 is roughly where we [4:54] see the the well, the black the black [4:57] line, sorry, the black line. Um [4:59] and it's a significant leap. Um [5:02] this one also shows cost. So, obviously, [5:04] um the cost has increased. Uh but, uh [5:07] looking at what we've seen over the past [5:09] year, [5:10] um [5:11] we are expecting the costs obviously to [5:13] also align after an initial period. Uh [5:17] but, it is such a [5:18] significant leap and I think everything [5:21] that I have in my slides, I had to go [5:23] through again and review again in light [5:26] of the new model capabilities. Uh so, [5:29] I've tried my best to make it updated. [5:32] Uh choose your own favorites. Try to [5:34] apply what I'm saying to to to your [5:37] tools. Some of you are of course [5:38] constrained by your employers. I'm sorry [5:41] for you, but uh you know, that's how it [5:42] is. [5:43] Um but, of Of we need to keep giving [5:46] arguments. Uh [5:47] to be honest with you, [5:49] and this is maybe a bit controversial, [5:51] um but I think over time these models uh [5:54] don't show sign of plateauing yet. At [5:57] some point, you know, they will probably [5:59] plateau. [6:00] But right now there is no evidence that [6:02] they will plateau in the short to medium [6:04] term. And I believe that the need for [6:06] harnesses um [6:08] will sort of uh become less and less. [6:11] Um so over time maybe it doesn't really [6:14] matter what harness we use. But today [6:17] uh it it does matter. [6:20] Um I'm going to kick off with 10 tips, [6:22] but the first tip is tip zero, and that [6:24] is essentially if you are new, I mean a [6:26] lot of you still write your own code, um [6:29] maybe supported by AI, hopefully [6:30] supported by AI. And some of you have [6:33] converted and sort of stopped writing [6:34] code. [6:35] Um either way, I believe the most [6:37] important thing is to approach this with [6:40] a pair programming mindset. And I think [6:43] we have a choice as developers and [6:45] non-developers that we can use AI in a [6:47] lazy way, and essentially just throw a [6:49] prompt at it and accept whatever comes [6:51] out. And I think we if we do that, we [6:54] risk maybe [6:57] becoming more stupid over time. [6:59] Uh but if we choose to actively [7:01] collaborate with the AI, I think we can [7:04] become even better versions of ourselves [7:06] and not just become passive sort of [7:08] takers of AI. [7:09] Um but that is a choice, and you need to [7:11] make that choice. I'm a big fan of [7:13] something called compound engineering. [7:15] How many of you have heard about [7:17] compound engineering? [7:19] Not many. It's a fairly new thing. I [7:21] believe it was coined by a company [7:23] called Every [7:24] uh last fall. And the concept is very [7:26] simple. I want my AI to learn as we work [7:30] together. [7:31] I want it to improve uh every rabbit [7:34] hole we go down, every mistake that it [7:37] makes, [7:38] I never want to spend time on that [7:40] mistake ever again. [7:42] That is my ambition. Every time it's [7:44] going to be smarter and smarter and [7:45] smarter together with me. Guided by me. [7:50] Uh in Norwegian, rentes rentes effect, [7:52] compounding. And uh this is definitely [7:55] possible to achieve today, and I believe [7:58] it's going to be even more achievable as [8:00] the models grow stronger. So, I'll talk [8:03] about that in my tips. Uh another uh [8:06] sort of tip zero that I want to share, [8:09] uh which is a fairly simple. The guy on [8:11] the screen here is Many of you probably [8:13] know him. He's This is Boris, the [8:14] creator of Claude Code. I had the [8:16] pleasure of talking with him a few [8:18] times. This was actually at the meetup [8:21] that we host uh here in Oslo. And every [8:23] time I ask him a question like, "When do [8:25] you think it's going to be possible to [8:26] do this?" or "When do you think we can [8:28] do that?" He sort of always sort of like [8:30] just said, "Yeah, well, you can just ask [8:32] Claude to do that. It can do that." And [8:34] I was like, "Okay." And then I started [8:36] actually thinking about it. Um and it's [8:39] true. You can actually ask Claude, um [8:42] and you we need to start practicing [8:44] asking Claude or your favorite AI. [8:46] Because I think as adults, we have this [8:48] very fixed view on what is possible and [8:51] what is not possible. [8:52] It's something that is ingrained, and [8:54] it's something that we we are used to uh [8:56] not changing very frequently. [8:59] And we can learn from our kids because [9:01] they'll say, "Well, why can't we just do [9:03] that?" [9:05] So, what was not possible just a few [9:08] months ago might just be possible now. [9:11] And I think we need to keep [9:13] recalibrating the definition of what is [9:15] possible. [9:17] So, we should ask Claude. I even put it [9:19] on my on the back of my hair so that you [9:21] can actually see, uh you know, [9:23] just ask Claude. So, every time the [9:25] simple answer is just ask Claude. Keep [9:28] that in mind when I go through the tips. [9:30] I believe it's more about mindset when [9:32] we are changing the way we work with [9:34] these tools than it is really about [9:37] technology. Of course, it's enabled by [9:38] technology, but I think it's really [9:40] about applying our hard-earned lessons [9:44] as developers [9:45] and rethinking how we actually work [9:47] together with AI. [9:49] So, here are my 10 tips. I'm going to go [9:51] through them. Maybe they're not exactly [9:53] tips. They may be categories of tips. [9:55] So, I've just crammed a lot of things [9:57] into each of these categories. So, [9:59] buckle up, fasten your seat belts. I'm [10:00] going to go through this very rapidly [10:03] and I'll try to give you as much as [10:04] possible in the time that we have left. [10:08] Um first and foremost, most importantly, [10:11] context is king. And I think this is the [10:13] single most important thing we control [10:16] and that influences the output of [10:18] whatever the AI is doing. Not just for [10:20] development, for any use of AI. [10:23] Uh and context is not only [10:27] critical, but it's also a scarce [10:29] resource. It's something that we need to [10:31] treat with care and essentially our job [10:33] is to try to optimize the highest impact [10:37] tokens that we provide to the AI. [10:40] And I think it's important for everyone [10:42] to to know and be aware that the context [10:45] window is a finite of a finite size. So, [10:48] essentially, I like to talk about it as [10:50] a glass and every time we start a new [10:53] session, certain things gets filled into [10:55] the glass. [10:56] The system prompt, the agent.md or the [10:58] Claude.md file, um any tool definitions [11:01] like our MCP servers, the name and the [11:04] description of the tools, [11:06] our skills, not the entire skill, but [11:08] the name and the description of each [11:10] skill. [11:11] All of this adds into the glass. [11:14] And then, of course, our conversation, [11:16] our input to Claude or your agent, [11:19] uh and and the output, including any [11:22] tool calls and all the thinking [11:24] processes. And it adds up. Uh the glass [11:27] has been pretty stable now for the past [11:29] sort of year, year and a half at around [11:31] 200,000 tokens and then a few months ago [11:34] we started seeing the introduction of a [11:37] million [11:39] tokens in window size. That's a pretty [11:41] significant increase compared to [11:44] 200,000. [11:45] Um but [11:49] irregardless of the size of the glass, [11:51] what we have seen is that the results [11:54] they start to deteriorate when we [11:56] approach somewhere around 70-80% of the [12:00] glass. [12:01] That means that we want to avoid filling [12:04] the glass. But what [12:06] what happens when we fill the glass, all [12:08] new harnesses will auto compact the [12:11] content of our glass. So they will sort [12:13] of gracefully allow us to keep going. [12:15] But we generally don't want that to [12:17] happen. [12:18] And we've seen that if we if we approach [12:21] full glass, the results starts to [12:24] deteriorate. So [12:26] the key tip for you is to keep an eye on [12:28] your context. Manage your context. Use [12:31] the tools you have available, make it um [12:34] something that you control rather than [12:36] leaving it up to the harnesses. [12:38] Um [12:40] if you use Claude code, you can type in [12:42] {slash} status line [12:44] and you can essentially spell out show [12:47] me my context window as a battery [12:49] indicator [12:50] visually in green or whatever you want. [12:53] So just ask Claude, right? [12:56] Um if you're using something like [12:58] cursor, you can also turn on [13:01] you know the or change to the default [13:02] behavior where you actually always see [13:04] context, you can see the usage [13:06] summaries. And if you're wondering [13:08] what's eating up your context window [13:10] where you're actually filling up the [13:12] glass, type {slash} context. [13:15] Um it's it's something that you don't [13:18] have to do all the time, but keep an eye [13:19] on that window and and pay attention to [13:23] what you put in the context window. [13:25] Those of you who the talk prior to this [13:27] with Mats, [13:29] he mentioned also that [13:31] if you really want to preserve context [13:33] and avoid certain things entering into [13:36] inference or the LLM, [13:38] you know, you can lean towards CLI tools [13:42] or functions and allow a programmatic [13:46] essentially deterministic behavior [13:48] outside of inference. Claude doesn't [13:50] have to necessarily look at all the data [13:53] in a database. You can probably process [13:56] the information and then extract that [13:58] with code and hand it to your to your [14:02] favorite AI. So, be precious or treat [14:06] context as something precious and keep [14:08] an eye on it. I think it's the most [14:10] important part. [14:11] If you do have to auto compact, well, [14:13] then you should guide the auto [14:15] compaction. So, use {slash} compact and [14:18] then provide specific instructions. [14:21] Forget about all of our debugging, but [14:23] remember everything else. All right. You [14:25] can guide the compaction. [14:27] My favorite approach is actually to I [14:30] have a couple of skills and I [14:32] essentially said that I say let's [14:35] continue later. And then Claude will [14:38] automatically summarize the session, [14:41] put it in a markdown file, and then I I [14:44] do {slash} reset or {slash} clear, and [14:46] then I start a new session and it and I [14:49] just say continue work. And it will pick [14:51] up the file and it will continue from [14:53] where we left off. [14:55] Either way, manage your context. Use [14:58] rules. Rules is the is the first place [15:01] where we can essentially guide and [15:03] compensate for model behavior. And [15:07] actually, [15:09] whether or not you use Claude or or [15:11] other harnesses, you can put your rules [15:13] in the agent.md file or in the Claude.md [15:16] file if you're using Claude and you want [15:19] sort of [15:20] both or different tools to to work, You [15:22] can just say at agents.md or the other [15:25] way around. You can have an agents.md [15:26] file and you just say at Claude.md. [15:29] And either harness will pick up the same [15:32] rules. So, that's a little hack that we [15:34] can use. [15:35] Remember that the Claude.md file always [15:38] enters the glass every time we start a [15:40] new conversation. The tool definitions [15:43] always enter the glass every time we [15:44] start a new conversation or reset our [15:46] context window. [15:48] But, [15:49] skills, [15:50] they enter the window the first time we [15:53] start a session, but if we do {slash} [15:56] compact or we let it auto compact, [15:59] the skill definitions do not re-enter [16:01] the context window. Only the ones that [16:03] have been [16:05] invoked during the session. [16:08] Uh that's something that trips a lot of [16:10] people up. Uh so, just be aware if you [16:13] let it compact. [16:16] Treat rules um and also the concept of [16:19] memory as something that is not a [16:22] one-off thing. You need to manage your [16:25] rules. You need to manage your memory. [16:28] Um and over time, you need to make sure [16:30] that your Claude.md or your agents.md [16:33] does not grow out of proportions, right? [16:36] The problem with filling the context [16:37] window and why we see deteriorating [16:39] results is essentially that we end up [16:41] with confusing information and then [16:44] eventually the agent will start [16:45] forgetting or [16:47] ignoring certain parts. If some of our [16:50] rules are critical and they get mixed up [16:52] with too much information, [16:54] we don't want that. [16:57] Memory um is of course an emerging [17:00] concept in all harnesses. In its [17:02] simplest form, it's essentially a way [17:04] for us to persist state between sessions [17:07] in a text file, typically a markdown [17:09] file. [17:10] Uh in Claude, we have a file called [17:12] memory.md. [17:13] It lives alongside of Claude.md, um Um, [17:16] but it lives in our global settings um [17:19] or in our global folder, but you can [17:21] also have project-specific memory. It's [17:24] a bit of a hidden thing, [17:25] but you can always say, "What do you [17:27] know about me?" or use {slash} memory [17:29] and you can actually edit the memory [17:31] yourself. Um, you can also just prompt [17:34] Claude and say, [17:35] "Forget this." or "Remember this." [17:38] right? [17:39] Make sure that we remember this for the [17:41] future and it will add it to memory. [17:43] Um, but actively manage it and prune the [17:46] rule files. [17:48] Okay, I asked ChatGPT to help me [17:50] visualize this thing. So, the way I I [17:53] think about rules, but also in general [17:55] everything we put in place around our [17:57] models in harnesses is essentially [18:00] scaffolding, right? And why do we need [18:01] it? Well, it's sort of to hold the model [18:04] up so that it doesn't fall over [18:06] and it's to compensate for the [18:08] inabilities [18:10] that these models have. [18:12] What do we put in our Claude MD file? Do [18:14] this, don't do that, etc., right? The [18:16] simplest form of scaffolding is our [18:18] Claude MD or agents MD file. [18:21] But [18:22] what I think a lot of people do wrong is [18:24] that you invest in your Claude MD or [18:27] your agents MD [18:29] and then we get a new model [18:30] and we're so happy with our Claude MD or [18:33] our agents MD [18:34] that we just keep it and we keep [18:35] building on it. [18:37] And today of all days, after what [18:40] happened and what came out yesterday [18:44] I just wanted you to think about this [18:45] and have a have a have a view on this [18:48] because what happens is that the [18:50] scaffolding we put in place risk holding [18:53] back the models. This was [18:56] uh, ChatGPT's way of showcasing that. [18:59] Uh, so essentially my recommendation to [19:02] all of you is actually go home today and [19:05] either just remove your Claude MD and [19:08] give it some tasks and see how it [19:09] performs. [19:10] But at the very least, I know because [19:12] most people won't do that. They're like, [19:14] "No, it's precious and I need to." Then [19:16] you at least point Claude to it and say, [19:19] "You now have superpowers. What would [19:21] you change here? What could hold you [19:22] back? What should we remove?" Just just [19:24] just ask Claude, right? Um, and this is [19:27] something we should do every time we get [19:30] a new model because the capabilities are [19:32] essentially exponentially growing right [19:35] now and we might actually be holding [19:37] them back because we have been too [19:39] specific in our rules. Do this, this, [19:41] this in this sequence. Maybe the model [19:43] now can do it in a completely different [19:45] way, in a new way. [19:47] So, throw it out and start fresh. [19:49] Skills. People ask me, "What's the [19:51] number one thing we should invest in in [19:53] 2026? What should I learn?" How many of [19:56] you use skills? [19:58] Those of you didn't raise your hand, [20:01] you have one job. Start using skills. [20:04] Skills is portable. It's something that [20:06] the entire industry is one of those rare [20:07] moments in our world where [20:11] someone comes up with a stupid simple [20:13] yet brilliant idea and then the rest [20:15] says, [20:16] "That's actually stupid simple and [20:18] brilliant. We're all going to support [20:20] it." [20:21] So, if you invest in skills, [20:23] right now maybe Claude code is the best [20:25] harness, but maybe in 2 months there's a [20:27] different harness. No problem. You can [20:30] migrate and plug and play skills. Your [20:33] rules, you can migrate and plug and [20:34] play. Just make sure that they are at [20:36] the adapted to the model. [20:39] Skills is very simply [20:40] a text file, markdown file, [20:43] a folder with a skill.md file. That's [20:46] the bare minimum skill. And essentially, [20:48] I think of skills as two main [20:49] categories. One, a way for us to teach [20:52] the AI our preferences, our taste, our [20:55] workflows, our ways of working, whatever [20:58] it is. [20:59] And the second category is a way for us [21:02] to equip AI with new capabilities, [21:05] capabilities that they may not [21:06] inherently have. [21:08] For instance, Claude [21:10] is not able to create images. Well, it [21:13] can create SVGs and do a lot of crazy [21:15] things, but it can't it's not an image [21:17] model. Similarly, it cannot produce [21:19] audio unless it builds a solution to [21:21] produce audio, which it can now. Um but [21:25] we can equip it with a skill and [21:27] essentially teach it that it can use the [21:29] Nano Banana API. And now all of a sudden [21:32] Claude can produce images. Or we can [21:35] give it a skill that teaches it how to [21:36] use uh the 11 Labs API. And then all of [21:39] a sudden it can create uh you know, your [21:41] own podcast episode if you want to. [21:43] So, skills for our preferences and [21:45] tastes and workflows or new [21:47] capabilities, essentially. [21:49] And of course, as developers, we can [21:50] also use uh some of the more advanced [21:52] features in skills, which is essentially [21:54] that we can bundle up in our skill uh [21:57] templates, references, [21:59] uh uh we can do use hierarchies uh to [22:02] essentially manage the context of skills [22:04] as well. And maybe most importantly, we [22:06] can enforce deterministic behavior from [22:11] what is inherently an uh [22:13] non-deterministic thing, LLMs, uh by [22:16] using scripts and essentially ensuring [22:18] that every time we do something, it's [22:20] done this exact way. [22:22] Which is actually incredibly uh [22:24] powerful. [22:26] Um [22:27] for those of you who are um new to [22:29] skills, you can also say that this skill [22:32] cannot be uh automatically invoked by [22:34] the model. So, I want to be in control [22:36] and only the user can invoke it. Then [22:39] you just add the flag disable model [22:41] invocation true to the front matter, the [22:44] top of the of the skill file. Um if you [22:47] want it to not be a slash command uh and [22:50] only let the model invoke it, well, then [22:52] you just put user invokable false. [22:55] For some reason they have this reverse [22:57] logic in how they uh create their [23:00] settings. Uh go build skills. Don't [23:03] write skills yourselves. [23:05] Use a ask Claude. [23:07] The best way to create a skill is to do [23:10] a meaningful piece of work. [23:13] So So give feedback, ask your agent to [23:16] do something, give feedback, and get it [23:18] to the point where you're happy, and [23:20] then instead of celebrating, you say, [23:22] "Now let's turn this into a repeatable [23:24] skill." [23:27] My rule of thumb is if I do something [23:29] more than once, [23:30] it probably deserves to become a skill. [23:34] Check your skills in, share it with the [23:36] team when that's relevant. Um and uh the [23:39] same with the Claude MD file. In your [23:41] repository, it should be shared [23:44] knowledge, and then you can still have [23:45] your own personal preferences in your [23:47] local Claude MD or your global Claude [23:50] MD. [23:51] Or or agents MD. [23:53] >> [snorts] [23:53] >> Uh essentially now skills is the same as [23:56] slash commands. They're They're They're [23:57] It's a bit confusing because slash [23:59] commands existed long before we had [24:00] skills. Um but you can chain skills [24:03] together. Uh you can have your uh your [24:06] skills reference other skills. Um you [24:08] can have skills uh accept arguments. [24:11] Um so essentially, you can do everything [24:13] we previously could do with slash [24:14] commands as well. Uh and if you don't [24:16] know the syntax, you don't know [24:18] everything that you know you can do, [24:22] just ask Claude, right? You just ask [24:24] Claude and say, "Hey, let's make sure [24:25] that this skill is not invoked by by the [24:27] model. It's only Okay." Then it will do [24:29] it for you. Um one last uh advanced tip [24:32] is that with skills and uh and uh and [24:36] sub-agents as well, we can actually do [24:38] something called dynamic context [24:40] injection by uh using an exclamation [24:43] mark [24:44] in the skill [24:45] uh and a bash command. And what happens [24:47] then is that uh we actually do a [24:50] pre-process step where it runs the [24:52] command, and it takes the output of the [24:54] command, and it injects it in. So we do [24:56] something outside of inference and it [24:59] becomes part of the context of the [25:00] skill. [25:01] So, very clever thing which we can of [25:03] course use to our advantage for a lot of [25:05] things, such as the example you see on [25:07] screen. [25:10] Yeah, as I as I mentioned, we can [25:12] combine them. [25:13] Um use the skill creator skill when you [25:16] build skills. Don't write skills [25:18] yourselves. [25:19] Uh don't go and download uh [25:22] a thousand skills from skills.sh. [25:25] There's a lot of bad skills out there, [25:26] so there's also a lot of attack vectors. [25:29] So, [25:30] my recommendation is the best skills are [25:32] the ones you build yourself together [25:34] with your AI. [25:35] Uh feel free to go online and find [25:38] interesting skills, but then just go to [25:41] your AI and say, "Hey, [25:43] let's build this skill for us. [25:46] Draw inspiration from this skill, [25:48] right?" [25:49] Uh then you are uh [25:52] more safe. [25:53] Skill creator, there's there's it's a [25:55] it's a it's an open-source uh skill uh [25:58] that Anthropic has. ChatGPT has a [26:00] built-in one as well. My honest take, [26:03] even though I'm of course a fanboy of [26:05] Claude, is actually that the the the [26:07] Claude skill creator is incredibly [26:09] powerful because they introduced evals [26:12] in the skill creator, which means that [26:14] if you use that, it will actually build [26:16] an eval suite if you ask it to, and it [26:18] will test, and it will show you, and it [26:21] will improve. So, it's got a built-in [26:22] self-improvement loop. And then you can [26:24] take any skill and you can do {slash} uh [26:27] skill creator and say, "Let's improve [26:29] this skill." And you point to your [26:30] skill. [26:32] You should try it out. It's it's really [26:33] really powerful. [26:36] Always start with a plan. This has been [26:38] a tip that I've been using for a long [26:39] time. [26:40] Um [26:42] and I would say that [26:43] more importantly than ever, this is [26:45] where we should invest our time as we [26:48] write less and less code ourselves, [26:50] and we sort of start gaining trust in [26:53] the output of the models. [26:55] We should invest more and more time in [26:57] describing specifically what we want. [27:00] That doesn't mean that we have to sit [27:02] and write very very long specifications. [27:04] Of course, we can collaborate with AI to [27:06] to achieve this. Plan mode changed the [27:08] whole mindset around AI assisted coding [27:11] when that was introduced in many of the [27:13] solutions. What code eventually cursor [27:15] got it as well. Now all of them have [27:17] some form of plan mode. Plan mode is [27:20] also a safe mode, which means that it [27:22] has read-only access. So you can not [27:24] only use it to create plans, but you can [27:26] also use it to safely explore [27:29] your code base. If you want to do [27:31] investigations, if you want to learn, [27:33] you can just enter plan mode and then I [27:35] give it a prompt that is not just about [27:37] creating a plan. So I would definitely [27:39] recommend doing that. I tend to want to [27:42] persist that plan. Again, back to [27:44] managing context. [27:46] In the past, I had to actively say put [27:48] it in a markdown file. Now it's started [27:51] to do a temporary markdown file, but I [27:53] don't trust that. So I sort of still [27:56] have a waste where I want to persist it. [27:58] Why do I do that? Well, one is that I [28:00] want it to survive between session [28:02] refreshes or where I clear the context [28:04] window. But secondly, it's the number [28:07] one step to [28:10] getting the AI to verify its own work [28:12] instead of me having to verify the work. [28:14] Because now after it's built whatever [28:16] it's built or fixed whatever it's fixed, [28:18] it can always measure it up against [28:21] whatever we said we would build in the [28:22] plan, right? [28:24] So keep it and then use it in the later [28:26] stages. [28:28] I use the progress document as well, [28:29] which you know, is not necessarily just [28:31] a plan, but essentially to manage [28:33] context between sessions. There's a lot [28:36] of frameworks. There's a lot There's [28:37] been a lot of trends where you know, [28:39] some [28:40] last year everyone was talking about [28:42] spec and spec kit and to be honest with [28:44] you, [28:45] choose whatever you want, right? The The [28:47] point is you need some sort of way to [28:50] structurally describe what you want and [28:53] give it uh the ability to use that [28:56] afterwards to check if it's done what it [28:58] was supposed to be doing. [29:00] So, yeah, frameworks are great. But um I [29:03] mean, keep it simple. The models are so [29:05] smart now that they'll be able to figure [29:08] out a great way to document. They'll be [29:10] figuring out a great way to actually [29:12] test against it afterwards. Uh so, have [29:15] a little faith in the models now. [29:17] They're just getting better and better, [29:18] right? [29:19] Um [29:21] I think um [29:23] one key thing that that I think is [29:25] important for us to to remember [29:28] is that [29:30] all the tools that we use today, [29:33] all the processes that we have, [29:37] they were put in place in a world where [29:39] we didn't have these tools. [29:43] And they were put in place because [29:45] writing code [29:46] was a expensive and scarce resource. [29:51] So, we tried to optimize around the fact [29:54] that writing code was the bottleneck. [29:58] I mean, you can disagree with me, but um [30:01] that's at least my view. [30:03] And now, [30:04] as we are starting to move in the [30:06] direction where maybe writing code is [30:10] becoming something that we can [30:14] trust the AI to do equally good and [30:16] maybe sometimes even better than us, [30:19] then we're essentially saying that the [30:20] bottleneck is no longer the bottleneck. [30:23] So, what happens is [30:26] my experience at least is that the [30:28] bottleneck actually starts shifting [30:30] outwards. [30:32] Not just in one direction, but in both [30:34] directions. So, now I've become the [30:37] bottleneck. [30:38] My AI can work in parallel. It can do so [30:41] many things that I'm now struggling with [30:44] keeping up with feeding it enough jobs [30:47] to be done. [30:49] Describing what I want, sharing my [30:51] intent, sharing my taste. [30:54] That's becoming the bottleneck, the [30:56] human bottleneck. [30:57] On the other end of it, of course, [31:00] checking, testing, verifying, validating [31:02] is becoming a bottleneck. [31:05] And it has been a bottleneck for a bit [31:06] of a time now, I would say. [31:08] So, we're shifting the bottlenecks to [31:11] new bottlenecks. [31:13] But, we still have the same tools and [31:15] the processes [31:17] as we had when the bottleneck was [31:19] writing code. [31:20] So, my my recommendation to everyone or [31:23] challenge to everyone is to also [31:25] challenge the tools, to challenge the [31:26] processes that we have. To rethink. [31:30] And uh [31:31] you know, we have now a very, very [31:33] powerful model. Maybe throw the problem [31:35] at that model and say, "How should we in [31:37] our team think about this? We have [31:40] always been working this way. [31:42] But, now as we start to trust AI to do [31:45] the code writing, how should we rethink [31:47] the tools and the processes around it? [31:49] Why do we do code reviews the way we've [31:51] done code reviews? Why do we do sprint [31:53] planning the way we do sprint planning? [31:55] Do we need retrospectives or should we [31:58] rethink how we do them? [32:00] And then the tools we have available to [32:03] do our job, do we need them in the same [32:05] way or do we need new tools? [32:08] So, I've been using the word chasing [32:10] bottlenecks. Of course, this one is [32:12] about coding, but honestly, I also want [32:15] you to go back to wherever you work and [32:16] bring the concept to them because this [32:19] applies to any knowledge work in my [32:21] opinion. It's not just about coding. [32:22] We're just We are just at the forefront. [32:25] We're maybe where we're seeing it [32:26] happening first. Eventually, we'll see [32:28] this in many different jobs, right? And [32:31] roles. And they have tools and processes [32:34] that are also going to be [32:36] outdated in a new world where the [32:39] bottlenecks are moving. All right. That [32:40] was my little philosophical share with [32:42] you. I'll I'll carry on. So, why did I [32:45] say that? Well, because I think if the [32:47] bottleneck moves, it's more important [32:48] than ever that we are actively engaged [32:52] in these human bottlenecks. And [32:55] essentially, on both sides of this, for [32:57] instance, [32:58] plan, right? [33:00] How do we scope something? [33:03] AI loves markdown. [33:04] And [33:06] over time, it becomes challenging for me [33:08] to stay engaged in a very long markdown [33:10] plan. So, I sort of end up converging [33:12] towards, "Yeah, that looks good. Let's [33:14] just go on and continue, right?" And [33:16] that's very, very dangerous. [33:19] Because then we are now sort of all [33:22] hands-off, and we are sort of [33:23] approaching this lazy way of working, [33:26] right? [33:26] I I I'm afraid of that. [33:29] And [33:30] um [33:31] One way to stay in the loop and make it [33:34] more interesting is [33:36] something that's become a bit of a trend [33:38] online recently, and probably you've [33:39] seen that. And that is essentially just [33:40] simply to say to your AI, "Instead of [33:43] giving me this markdown file, can you [33:44] provide it to me in a visually appealing [33:47] or interactive or engaging HTML file?" [33:50] And HTML is incredible. And of course, [33:53] you can then give it, you know, styles, [33:55] and you just turn it into a skill, so [33:56] you never have to say that ever again. [33:58] And now all of a sudden, you can [34:00] actually digest and have an engaging [34:03] sort of feedback loop with the AI. [34:05] Instead of just saying, "Yeah, yeah, [34:06] that looks good." [34:08] I guess some of you have done that [34:10] before. At least I have. So, [34:12] yeah. [34:13] Definitely use other [34:16] formats than just text if you want to [34:19] stay in the loop. [34:21] Oh, sorry. Yeah. [34:22] Um the other end of it as well, I think, [34:25] you know, [34:26] is to to look at the whole chain. And [34:28] one of my favorite plugins or set of [34:31] skills is something called superpowers. [34:33] How many of you have used superpowers? [34:36] Okay. Well, those of you had did not [34:38] raise your hand, you can take a picture [34:40] and you can go home and try this because [34:42] this is going to [34:43] blow your mind, I would say. [34:46] Superpowers [34:47] is essentially a collection of skills [34:49] that tries to sort of address all the [34:52] steps in a development process. But it [34:54] can also be used for other things than [34:55] development. [34:57] One fair warning is that if you sort of [35:00] run the whole process, all steps, it's a [35:03] very token intensive [35:05] process and it can definitely be [35:07] overkill for certain tasks. [35:10] So here again is where I would take the [35:13] skill and then I will ask Claude to [35:15] modify the skill for me and say, "Let's [35:18] not make the whole process model [35:21] invocable and then let me be in [35:23] control." Because then you can choose to [35:25] invoke the whole process if you want to, [35:28] but it doesn't happen for small things [35:30] where it shouldn't use it. [35:32] You can check it out. There are several [35:34] steps, but I want to bring out one very [35:36] important thing and that is essentially [35:38] the brainstorming skill. Brainstorming [35:40] skill is essentially plan mode on [35:42] steroids. And what was really, really [35:46] cool couple of months ago, they made an [35:48] update to it and then all of a sudden [35:51] Claude said to me, [35:53] "This might actually be easier to show [35:56] to you. Do you mind if I spin up a web [35:59] server and get your input?" And I was [36:01] like, "What? [36:02] Of course, yes, please do that." And now [36:05] the brainstorming skill does that. So [36:07] it's not just about showing you the [36:08] signs. It'll say, "Do you want to go in [36:10] this direction or you want to go in this [36:11] direction?" [36:13] But it can also show you [36:15] architecture choices, [36:17] you know, just in a visual way. So this [36:19] is sort of an automation of asking it to [36:22] show me this plan in a markdown file, [36:24] but with user input because it will show [36:27] [snorts] you do you want to do option [36:28] one, two, or three? And you can click [36:32] and it actually sends the feedback back [36:33] to Claude. Uh so, I would highly [36:36] recommend you try this out. Of course, [36:37] you can port that skill to your favorite [36:40] um coding agent. [36:42] Um [36:43] The last part of sort of this bottleneck [36:45] chasing is of course then how do we keep [36:48] up with reviewing and checking and [36:50] verifying that something is actually [36:52] done. And uh I think the mindset should [36:54] be like this. What tools do you use to [36:57] do your job? [36:59] And if you expect your coding agent to [37:01] do that job for you, [37:03] or at least parts of that job, that [37:05] coding agent needs the same tools and [37:08] the same context that you use. [37:11] A very cool exercise is actually to if [37:13] you're if you're using Claude Coder or [37:14] something, [37:15] uh try to start a day uh [37:18] in the terminal, and then uh every time [37:21] you have to leave the terminal [37:22] to do your job, apart from drinking [37:24] coffee, then write it down. [37:28] You have to go check Slack. [37:30] You have to go um you know, uh look up [37:33] something online, or do you have to go [37:34] check something in Jira or something? [37:36] All of these are signals of tools you [37:39] should probably consider giving to your [37:41] coding agent. [37:43] Right? So, it's a good exercise to just [37:44] figure out what tools [37:46] does my AI need? [37:49] Um the the smart people, hehe, I'm not [37:53] one of those, but the smart people, uh [37:55] they've also said this, right? Maybe the [37:57] single uh highest leverage that we can [37:59] uh that we can do right now is to give [38:01] AI a way to verify its own work. [38:05] Uh because I don't want my AI to say I'm [38:07] done, and then I have to go spin up the [38:10] dev server, open up Chrome, test it, go [38:14] through all of these flows, and then [38:15] only to figure out some error message [38:17] deep down in the console or whatever. [38:20] I just want the AI to do that for me. [38:22] So, I have to give it the tools and I [38:24] give have to give it a way to verify the [38:25] output. And of course, we have to of [38:27] course tell it what done looks like, [38:30] right? [38:31] So, you can of course now with many [38:34] different MCPs or plugins like the clone [38:37] the Chrome plugin or you have built-in [38:40] browsers like in in cursor, Claude [38:42] desktop app, Codex. So, you we already [38:45] have the the means to give it these [38:47] abilities, right? In a controlled way, [38:49] right? We can tell it what it can and [38:50] can't do. We can [38:52] opt in for permissions. [38:54] And then you can actually just just say [38:57] continue until you're done, right? [38:59] This is a bit slow, [39:01] right? It's not lightning fast to do [39:03] this. But in my opinion, that doesn't [39:05] matter. That can just keep running over [39:06] there and I can keep working over here. [39:09] That's fine. [39:10] Another way to give feedback. [39:13] Have any of you heard about this thing [39:15] called agentation? [39:17] None. Okay. Well, [39:19] you're getting a lot of value here [39:21] today, I think, because this one is [39:23] actually also a very simple thing where [39:26] we can inject essentially a little [39:29] toolbar on top of our in this case [39:31] Next.js application [39:33] and it allows us to run locally, but we [39:36] can now provide feedback while we're [39:39] using the application. We can draw, we [39:41] can click, it will capture the DOM [39:44] paths. So, it has the context, right? [39:48] And it's actually brilliant. [39:50] Now, they have a similar functionality [39:52] in the in the Claude desktop app. [39:55] If you use that, I mean, I use the [39:56] terminal, but for front end, I go over [39:58] to the Claude desktop app because there [40:01] we also have DOM specific [40:04] annotation. And the great thing is we [40:06] just click and we draw and we describe [40:10] and then we in this case just click copy [40:13] prompt and we paste it back into our [40:15] coding agent or in the Claude sub app, [40:18] uh it automatically feeds it back into [40:19] the agent. [40:21] So, addressing and chasing those [40:23] bottlenecks, right? How can I give [40:25] feedback faster? How can I give my agent [40:28] ways to verify its own work? [40:35] Yesterday, we got uh Fable 5 [40:38] and Mythos for those who are uh lucky [40:40] enough to be in the certain industries. [40:42] Um and uh Tarik is one of the developers [40:45] on the Claude Code team. Uh [40:47] uh they made this post, "We used to [40:50] verify that Claude did the work right. [40:53] Now, we verify that it's doing the right [40:56] work." [40:57] And I think that's something we should [40:59] obviously um draw some inspiration from. [41:01] And there are some mindsets that these [41:03] people that are definitely working on [41:05] the forefront uh [41:07] uh are seeing before we're able to even [41:09] grasp and think about this, right? Um [41:12] so, instead of us prompting, instead of [41:14] us spending our time on verifying uh [41:17] that it ended up doing it, they're sort [41:19] of starting to get to the point where [41:21] they're trusting that it can verify its [41:23] own work. And they shift the focus uh to [41:26] actually managing and ensuring that it's [41:28] doing the right work. That it's uh that [41:30] it has the essentially the harness [41:33] around it to guide and and do work over [41:36] time. So, instead of us just uh deciding [41:39] every single piece of work, we're [41:40] essentially moving towards defining a [41:42] goal or an outcome uh something to be [41:45] achieved, [41:46] and then we put more trust in that the [41:49] models are now more capable to actually [41:51] do that without the the um [41:55] How was it called? Støttehjul in [41:56] Norwegian. [41:58] I don't [41:59] Support wheels? Yeah, maybe. [42:02] In both uh Codex and in Claude training [42:05] wheels, exactly. [42:06] In both Codex and in Claude Code, we now [42:09] have uh something called uh {slash} [42:11] goal. [42:12] And uh slash goal is essentially, very [42:14] simply put, um [42:17] well, maybe an extension of uh um of the [42:20] uh loop that we got introduced earlier [42:23] this year. Uh but essentially, what we [42:26] say is instead of giving a description [42:28] of what to do, we're essentially telling [42:31] it what we want to achieve. [42:33] An outcome, [42:35] um [42:36] um [42:36] objectives, um and then we leave it up [42:40] to um our agent to figure out how to do [42:43] it. [42:45] And then that that might sound like, [42:46] "Oh, now we're sort of stepping away and [42:48] and and not having any control." But [42:50] that's not true. [42:51] Because our agent is, of course, bound [42:54] by the tools that we equip it with and [42:57] the skills that we give it. So, our way [42:58] to guide, repeatedly, is, of course, to [43:01] invest in skills and invest in tools, [43:04] right? [43:05] And then [43:07] gain the trust and let it run. And the [43:09] way both of these uh implementations [43:12] work is essentially um a multi-agent [43:15] approach where we just say, "One [43:17] important thing is that we don't let the [43:19] same agent evaluate whether or not it's [43:21] achieved the uh the goal." [43:23] And and and then everything else is just [43:26] a loop. [43:27] So, every time it runs the loop, it it [43:30] says that I'm done, and then another [43:32] agent [43:34] verifies or checks. And if it disagrees, [43:37] the loop starts again, and we keep [43:39] going. [43:40] Um which is simple, but uh uh shows [43:45] incredibly better results. But again, if [43:48] you have a very, very um [43:50] ambitious goal, of course, this can be [43:53] expensive. A lot of the tips that I give [43:55] you are sort of assuming you're token [43:57] rich. [44:00] Okay. So, [44:02] speaking of which, [44:04] I used to have the tip, "Use the right [44:06] model." [44:07] And then I changed it to use the best [44:09] model. Now, maybe in a week I'll change [44:12] it back because I know this is going to [44:14] be expensive after what we got [44:16] yesterday. [44:17] Uh but honestly, [44:21] I view it this way. [44:22] The time that I have to spend fixing, [44:25] correcting, guiding [44:27] with a lesser model or a mediocre model [44:30] or a sub top model, [44:32] uh [44:34] I believe we uh can can essentially [44:37] defend the additional cost of running a [44:40] superior model. [44:42] And again, that's easy to say if you, [44:44] you know, are privileged with the [44:46] tokens. [44:47] Uh of course, you need to think of it [44:49] slightly differently if you are token [44:51] poor. [44:52] I also laugh when I see people online [44:54] saying, "Well, this is not possible to [44:56] do on the $20 plan." It's like, "No. [44:59] I I'm sorry, you can't do this on the [45:01] $20 plan." Then I I would ask myself, [45:03] "What is my time worth?" And if I can [45:06] save time or be 10x the version of [45:08] myself, I at least have no problem [45:11] saying that I'll spend $1,000 Oh, sorry, [45:13] not $1,000. [45:16] Maybe sometime, but $100 or $200 every [45:20] month. Uh [45:21] but it's each and every one to [45:22] themselves, right? Uh you can definitely [45:25] do a lot to manage [45:27] um [45:28] token use. [45:30] Uh if you are scratching your head and [45:32] wondering what's consuming tokens and [45:34] what can I do to achieve it if you want [45:36] to optimize? My single most important [45:39] tip for you is to run {slash} {slash} [45:41] usage. They just added it to the SDK, [45:44] which means I think we'll see it in the [45:47] desktop app in in days because that was [45:50] the limitation before. But in the [45:52] terminal, do {slash} {slash} usage, [45:54] sorry, and then scroll down because [45:57] below your sort of session data, they [45:59] have recently, this is fairly new, uh [46:03] given you a summary of what's consuming [46:05] tokens. And then if you scroll even [46:07] further down, you'll actually see [46:09] explicit mentions of what skills and [46:12] what they're consuming. [46:13] And then often you'll find the culprit [46:15] there. If you're sort of now seeing [46:17] like, "Whoa, I don't understand. I've [46:19] only used it a little bit and it's [46:21] already spent my quota." [46:24] slash usage go down and you'll see that, [46:27] "Oh, it's that superpowers plugin that [46:29] Alex recommended that and it's burning [46:31] all of my tokens." [46:33] So yeah, [46:34] you can optimize definitely. [46:37] Make use of subagents. [46:39] Subagents is are [46:41] way to essentially engineer [46:44] infinite context context windows. [46:47] Because each subagent has their own [46:50] context window. [46:51] And last night um [46:54] they also introduced nesting [46:57] of subagents, which is like I I [47:00] I need to wrap my head around what we [47:02] can do with this. Which means that we [47:03] can essentially have subagents spin up [47:06] additional subagents. And they put a cap [47:09] for now five levels deep. But I mean, [47:12] this is just insane. You can also fork [47:15] context when you use subagents. This is [47:16] a bit more advanced, but think of it [47:18] like this. The main agent spinning up [47:21] subagents, they will essentially start [47:23] with an empty glass and their input is [47:25] just whatever the prompt from the main [47:26] agent, right? But if we do have cases [47:29] where we think they should have access [47:30] to everything that we worked on so far, [47:33] we can essentially do a fork of the [47:35] context simply by saying [47:38] context [47:40] colon fork in the subagent definition. [47:43] So that's a useful thing in some cases. [47:46] But yeah, use subagents. You can [47:47] definitely invest in sort of predefining [47:50] subagents. [47:52] To be quite honest with you, I've done [47:54] that a lot, but now I've sort of started [47:56] to removing them because I see that the [47:59] latest models now, essentially after [48:01] Opus 48, are very capable of defining on [48:05] the fly and figuring out what are the [48:07] agents we need for the job. [48:09] And again, this is another thing that [48:11] may become a stale thing that is holding [48:14] your model back, right? Because maybe [48:17] you created a sub-agent last fall [48:20] and you were very specific about do [48:21] this, do this, do this, do this, right? [48:23] And then you just leave it there and it [48:25] So, yeah, maybe you should rethink your [48:27] sub-agents. Definitely use sub-agents, [48:30] but maybe don't invest too much time in [48:32] in all the specifics of each one. [48:35] Um time flies, but I will I will I still [48:37] have some time. So, next up hooks. Um [48:40] so, again, around how do we control? So, [48:44] context we can use sub-agents to to [48:46] essentially get more context in our [48:48] processes. Uh but [48:51] we also do want to have a way to put in [48:54] place guardrails. And hooks was invented [48:57] for that purpose, allowing us to [48:59] essentially stop the agent at certain [49:02] events outside of inference and and and [49:05] and enable deterministic behavior. [49:08] Because even though we can say [49:11] never ever ever do this, this, this in [49:14] your Claude MD file, that is not a [49:16] guardrail. [49:17] Uh we can pray and hope that it follows [49:20] the instructions and increasingly they [49:22] do, but they is not guaranteed. So, if [49:25] you need guarantees, you need to use you [49:27] need you need to use hooks. [49:29] Hooks is essentially something that will [49:31] be triggered on whatever events that we [49:34] specify. These are probably some of the [49:36] most [49:37] common events, but then if you go into [49:39] the documentation, there's a long list [49:42] of of growing [49:44] number of events available. For [49:46] instance, we can use the pre-tool use [49:48] hook or event to create a hook that [49:51] essentially checks what is the agent [49:53] trying to do. Uh is this something we [49:55] want to disallow and then we can put a [49:57] hard stop on the agent and say you're [49:59] not allowed to do RM [50:01] for instance. [50:03] We can enforce that. [50:04] Um and that's the safe way of doing it. [50:07] Uh we recently also got an if clause [50:09] support for if clauses in hook [50:11] definitions in core code, uh not yet in [50:14] other agent harnesses, but I'm sure this [50:16] will come in other harnesses as well. [50:18] Um so use the event types uh combined [50:22] with a matcher for instance, [50:24] uh and then put your logic in a script, [50:26] and then uh your your [50:28] you have a guardrail in place. Hooks can [50:30] also be used for other things than [50:31] guardrails. We can use it for instance [50:33] to say something like every time before [50:35] we do a a commit, we want to do this and [50:37] this. Or every time a file has changed, [50:40] we want to run a linter. We can do a lot [50:42] of these things for productivity and [50:44] workflows as well, where we enforce it. [50:47] Um and then uh essentially um uh [50:51] something like for instance Ralph [50:52] Wiggum, which was uh which which was a [50:54] popular thing earlier this year, is [50:57] essentially [50:59] uh achievable [51:00] uh by just having a hook uh on the stop [51:03] event where it says keep going. [51:07] Right. That That's essentially the [51:08] simplest implementation of a Ralph [51:10] Wiggum loop. [51:13] I said in my introduction that I'm very [51:15] passionate about compound engineering, [51:17] and I would just very much urge you to [51:20] have that mindset when you work with AI [51:22] these days to say all the time, keep in [51:25] mind that you want it to learn from its [51:28] mistakes. You want it to reflect on what [51:30] you have done together. Uh you can turn [51:32] it into a skill or put it in a slash [51:35] command. You can even put it in a hook [51:38] if you want it to happen every time you [51:40] do a slash clear or every time you end [51:41] the session. So you can sort of [51:44] automate this process. But the simple [51:46] way is just to say we finally fixed [51:48] this. Now, let's learn from our mistakes [51:50] and never ever want to go down in this [51:52] rabbit hole ever again. [51:54] Or you say, let's reflect on our session [51:57] today. [51:59] What mistakes did we make? What are the [52:01] key learnings? Put it in a markdown [52:04] file. Or even better, turn it into a [52:06] skill. [52:07] So that it happens automatically next [52:09] time. [52:10] Um you can use this for patterns in your [52:13] code base and you can then turn those [52:15] patterns into skills for instance. [52:18] How do we write tests? [52:21] How do we um [52:22] um how do we essentially define our uh [52:25] commit messages? Uh I mean, you can do [52:27] simple things, but you can do really [52:29] powerful things as well. So just think [52:31] about how you onboard and train uh your [52:34] AI assistant. That's essentially the [52:36] mindset you need to have. [52:37] How many of you have ever used {slash} [52:40] insights? [52:42] Okay. Now now honestly, this one? [52:46] Okay, I'll stop for a second here. I'll [52:48] stop on this one. [52:50] {slash} insights. [52:51] All [52:52] AI uh coding harnesses, [52:55] they have [52:57] um a way to store and capture your [52:59] sessions. Most people might not be [53:02] aware. Uh this is what enables us to do [53:04] {slash} resume for instance in Claude. [53:07] But you can do this in any harness. They [53:09] don't have {slash} insights, but you can [53:12] you can do the same thing with your [53:14] favorite uh agent. [53:16] And essentially what it does is it looks [53:18] at the folder where all of the session [53:20] information is stored. So essentially, [53:22] everything you've done together. [53:24] And then the {slash} insight is [53:25] essentially just a skill, [53:27] which says something like, [53:29] analyze all of our sessions over the [53:31] past 30 days [53:32] and look for patterns, [53:34] draw out key learnings, where did we go [53:37] wrong, [53:38] uh where did we fail, what did we do [53:41] well, [53:42] and then it puts it all together into an [53:44] HTML report. So, when you run that [53:46] command, and if you don't have Claude [53:48] Code, you can do the same thing just by [53:49] saying that, "Analyze our session data, [53:51] extract, you know, everything that we [53:53] did bad or we could improve, and then [53:56] give me suggestions." And that's what it [53:58] does. It It It pats you on the back and [54:00] says, "Yeah, you you're a good boy. You [54:01] did all of these great things." [54:03] Great. Um but then it also shows you [54:07] what you can improve. And it might [54:10] actually also uh float uh things you [54:12] were not aware you could do. [54:14] Capabilities that are there that you [54:15] might not be aware of. And uh in [54:18] Claude's case, which you can also [54:19] instruct your agent to do, is provide me [54:21] with copy-pastable [54:23] uh prompts or examples, right? And [54:26] essentially what it does here is here's [54:28] things you can do in your Claude MD [54:29] file. Uh here are hooks that you should [54:31] consider introducing, which can avoid [54:33] these mistakes that happened 25 times in [54:35] the past 30 days. [54:37] And it just like it blows my mind what [54:39] you can learn from this. It only makes [54:41] sense if you've used uh the harness for [54:43] a little while, of course, and you have [54:45] some sessions. [54:46] And then you should just make a habit [54:48] out of doing this regularly. I mean, [54:49] it's This is compounding. This is like [54:52] how you can actually improve so much uh [54:54] if you just make use of it. And it's [54:56] actually very simple. [54:58] Um learn from Claude Code and apply it [55:01] to whatever agent you're using. [55:04] So, just have that mindset. We can [55:06] definitely uh update our memory and [55:08] rules, and we should do that. We should [55:09] actively manage it. We should try to [55:11] capture things and patterns into skills. [55:14] If we want to enforce it, we can [55:15] definitely use hooks to ensure that it [55:17] happens all the time, uh not leaving it [55:20] up to uh hoping that the AI will will do [55:22] it. Um and then just have that mindset [55:24] of continuously asking your AI to learn [55:27] from its mistakes. [55:29] You'll get so much better uh results [55:31] from working with AI. [55:33] Um not going to spend time on this too [55:35] much, but yeah, you should definitely [55:37] equip your AI with the tools and the [55:39] information it needs to do the job. And [55:41] MCP is definitely a way for us to equip [55:44] our AI with context and information, but [55:47] also to give it ability to perform [55:49] actions on our behalf. [55:50] Uh [55:51] a lot of people say MCP is dead and CLI [55:54] is and I I I don't agree, but I do as an [55:57] individual contributor developer lean [56:00] towards CLI tools when it's for me. [56:03] Uh because coding agents are excellent [56:05] at using bash commands and they are very [56:08] very good at learning how to use CLI [56:10] tools. So, it's it's less context heavy [56:13] in in most cases. I would lean to CLI [56:15] tools. But MCP still has a [56:18] big place [56:20] because this is how we can also [56:21] distribute the capabilities to [56:23] non-developers, to [56:25] other platforms and solutions which may [56:26] not be [56:28] agentic coding harnesses. [56:30] Uh so, yeah, give it the tools that it [56:32] needs to do the job. And then lastly, or [56:35] maybe not lastly, but tip number nine, [56:37] um [56:38] uh try to work in parallel. If you start [56:41] out and you start trusting the code [56:43] production, the code writing, you are [56:45] going to end up in a point where you're [56:48] drinking coffee while you're waiting for [56:49] your agents and it's a you know, [56:52] it's a limit to how many coffee cups we [56:54] can drink. So, you start thinking, how [56:57] can I now give more agents more work to [57:00] do, right? And and and and this can be [57:04] very addictive. [57:05] Uh and it can ruin marriages. Uh [57:09] I saved mine, but but [57:12] I would have to say I was a bit close [57:14] when Cloud Code launched remote control. [57:17] Uh because then I was sort of sitting [57:19] yeah, yeah, I'm listening to you and I [57:21] was always just trying to keep my agents [57:23] busy. So, maybe take a break once in a [57:25] while. [57:26] Um but you can start simply by obviously [57:29] running multiple sessions. We have all [57:31] the things we need, for instance, work [57:33] trees, which allows us to have [57:35] isolation, and we can do parallel work. [57:38] We become the bottleneck in giving it [57:40] tasks. You can use You can hook your [57:42] agents up to, for instance, [57:45] GitHub. In my case, I use GitHub issues, [57:48] and I've added Claude to my GitHub. And [57:51] before I brush my teeth in the evening, [57:54] I sort of just say, "At Claude, fix [57:56] this. At Claude, fix this. At Claude, [57:58] fix this." And then I see how many it [58:00] can finish before I finish brushing my [58:02] teeth. [58:03] My record is six, and I don't brush my [58:05] teeth very long. But, [58:07] you can definitely do that. Remote [58:08] control allows us to go out and touch [58:10] grass [58:12] and get some fresh air once in a while [58:14] while still keeping our agent busy when [58:16] they need us. [58:17] But, [58:20] 2 days ago, or [58:21] we got the internet cooking with a new [58:24] concept. Because these people, Peter [58:27] Steinberger and Boris, posted, "I've [58:30] prompting. My job now is writing loops [58:33] where Claude prompts other Claudes." And [58:35] the internet is like, "What does it [58:37] mean?" Well, [58:39] and then Addy from Google wrote an [58:42] article and coined the sort of loop [58:44] engineering. [58:45] So, I guess we've gone from [58:48] less capable models with small context [58:50] windows, and we invented prompt [58:52] engineering because we wanted to [58:53] optimize sort of the one-shot [58:56] tasks. And then it evolved into context [58:59] engineering as the context window grew [59:01] larger, and we could do multi multiple [59:03] tasks. We also got tools like MCP. [59:06] And then recently sort of migrated into [59:09] or evolved into what we call harness [59:11] engineering, right? Which is really [59:13] around putting these context engineering [59:16] practices at scale, [59:18] managing larger loops, longer-running [59:21] tasks. And then now, obviously, we need [59:24] to start talking about loop engineering. [59:25] But, what is it really? I think it's [59:27] really uh about uh using the constructs [59:30] we now have available and the [59:32] capabilities of the models to [59:34] essentially, instead of prompting, we [59:36] give it a stop condition, we give it a [59:38] goal, we give it a target, and then we [59:40] give it the means to work potentially at [59:43] large scale. Potentially [59:46] hundreds, if not thousands, of agents [59:49] and a lot of tokens. [59:51] >> [snorts] [59:51] >> But, you can achieve uh incredible [59:53] things. But, don't let this sort of uh [59:56] fool you. I think a lot of the problems [59:58] we try to solve we probably can solve in [60:00] a much simpler But, in essence, today we [60:02] have everything we need to create loops [60:05] and work in loops. And I think the only [60:07] thing we need to think about is we need [60:09] a way for our agents to uh store state [60:12] or persist tasks or to-do lists across [60:15] sessions. Because then we can say, [60:17] "Every night, check if there's work to [60:19] be done. And if so, do the work until [60:21] it's done." [60:23] And essentially, that's sort of the [60:25] simplest way to talk about loop [60:26] engineering. [60:27] But, feel free to dive into it. Claude [60:29] made these slides, by the way. I'll give [60:31] him feedback if you didn't like them. Um [60:34] we have all the mechanisms. If you [60:35] really want to burn tokens and see like [60:38] incredible things, but still very, very [60:40] expensive, you should try something [60:42] called Ultra Code, which we got 2 and [60:44] 1/2 weeks ago uh in Claude Code. And [60:47] it's essentially uh a way to uh tell [60:50] Claude to write its own harness on top [60:54] of uh Claude Code. And it will [60:56] essentially create a repeatable [60:57] workflow, which could involve many, [60:59] many, many, many agents to solve very, [61:02] very complex things. Definitely overkill [61:04] for a lot of things, but very [61:06] interesting uh for a lot of things. [61:07] Remember to ask Claude. [61:10] Also, ask it to build tools. And [61:11] remember to mention to Claude that it is [61:14] not a human. [61:16] Remember to mention to Claude that it is [61:18] Claude and that it can use Claude to [61:20] solve problems. [61:22] Cuz a lot of times if you ask an AI, it [61:24] will think like a developer because it's [61:25] trained on how we solve problems and it [61:28] will write a regex for that problem. [61:31] Instead it could have just used Claw in [61:33] headless mode or used the OpenAI API and [61:36] actually send off and do a sentiment [61:38] analysis or whatever, right? Just remind [61:40] it, give it a nudge and you'll see [61:41] amazing solutions. Remember to be the [61:44] human loop. My time is up, sorry about [61:45] that. I tried to time it but [61:48] remember that we still need to check but [61:51] figure out how you can make it easier to [61:53] check to to invest less time in these [61:56] things. Yeah, and follow me on LinkedIn, [61:59] add me on LinkedIn [62:00] and check out my YouTube channel if you [62:02] want to and I'll stick around for [62:03] questions. Thank you very much. [62:05] >> [applause]