# How I Tamed Claude - Emmz Rendle - NDC Copenhagen 2026

## Executive summary

The talk details a structured methodology for leveraging advanced coding agents, particularly Claude, to achieve production-grade code generation and maintainability. The core principle is moving away from 'vibe coding' by implementing a spec-driven workflow that enforces separation of concerns among multiple specialized AI agents (Orchestrator, Worker, Reviewer). This process emphasizes defining clear requirements, maintaining an auditable development history, and managing context to ensure the final solution is robust and reliable.

## Key takeaways

- Spec First, Code Second: The workflow must begin with a detailed specification (the 'spec'), which acts as the source of truth for the entire project. The speaker recommends using OpenSpec's four phases: Explore $ ightarrow$ Propose $ ightarrow$ Apply $ ightarrow$ Archive [~10:35].
- Separation of Agent Powers: The system must enforce a clear separation of duties among agents. The Worker writes code, the Reviewer validates it against the spec and design, and the Orchestrator manages commits and pushes; crucially, neither the Worker nor the Reviewer can approve or commit work [~18:30].
- Definition of Done (DoD): A rigorous Definition of Done is critical for preventing scope creep and ensuring quality. This includes mandatory checks like all tests being green, achieving good coverage, running `net format` twice, and completing the entire task group [~24:15].
- Context Management: To prevent agents from becoming confused or hallucinating outdated information, context must be actively managed. Techniques include using Graphify (for code mapping), Context Mode (to summarize raw output and reduce token count by 70-80%), and dedicated MCP services like Context 7 for accessing up-to-date documentation [~31:25].

## Technical details

- Agent Architecture & Workflow: The recommended workflow uses OpenSpec, which guides the process through four phases: Explore (interviewing to define requirements), Propose (turning requirements into a design/spec list), Apply (agent writes code and runs tests), and Archive (ready for production commit) [~10:35].
- Multi-Agent System: The system employs specialized agents: the Orchestrator (manages flow, commits, opens PRs), the Worker (writes code, runs on Sonnet model), and the Reviewer (validates output against spec/design, runs on Opus) [~18:30].
- Claude Models & Context: The speaker discusses Claude's models: Haiku (low capability), Sonnet (day-to-day tasks), and Opus (highly capable/overthinking). While context windows are large (Opus has 1 million tokens), the advice is to keep the active context slim, ideally under 200,000 tokens [~6:35].
- Agent Instructions: Instructions for agents should be placed in a dedicated file (e.g., `claude.md`). This includes defining the project's technology stack (e.g., ASP.NET Core 10, Razor Pages) to guide autocomplete and ensure factual adherence [~20:35].

## Practical implications

- Implement a strict, multi-agent workflow where the Orchestrator controls all commits and PRs.
- Treat the specification (spec) as the primary artifact; development progress must be tracked by updating this spec, not just writing code.
- Enforce human oversight at critical points (e.g., merging PRs, reviewing complex architectural decisions).
- Use specialized tools like Context Mode and Graphify to manage context window size and maintain an accurate understanding of the codebase state.

## Topics

AI Agents, Software Engineering Workflow, LLMs, DevOps, Context Management, Spec-Driven Development, OpenSpec, Claude (Anthropic), Graphify, Context Mode, Context 7, GitHub demonic AI

Source: https://www.youtube.com/watch?v=GoQzVjk8rzc