70% Context Is The Most Important Thing For AI Coding

The video introduces the problem with popular AI coding frameworks like Beemad and Speckit - they often fail to deliver on promises not because their methods are bad, but because they don't fit specific use cases. The creator explains that when building apps, most developers create custom workflows instead of using pre-made ones because workflows must align with the specific project being built. To build effective custom workflows, developers need to understand certain fundamental principles that every framework uses. This sets up the video's focus on teaching these underlying principles rather than promoting specific tools.

This section explains the critical concept of the context window - the amount of information an AI model can remember at once. Anything outside this window is lost from working memory with no way to recall it. The creator provides specific examples: Anthropic models have a 200k token context window while Gemini models have 1 million tokens. Despite these seemingly large numbers, the context window fills quickly because it contains not just system prompts and user messages, but also past messages, memory files, tools, MCP calls, and more. Understanding how to maximize this limited working space is essential for building workflows that make the model do exactly what you want.

Progressive disclosure is introduced as the most important principle in workflow design - revealing to the LLM only what matters right now and keeping attention focused on current needs rather than filling context with everything that might be needed in the future. While advanced models like Sonnet 4.5 have built-in context editing features and can filter noise using grep commands, this alone isn't enough. The creator gives a practical example: instead of asking Claude to fix all backend errors at once, it's better to ask it to check endpoints one by one. The skills feature in Claude Code exemplifies progressive disclosure, providing just enough information in descriptions for the AI to know when to use each skill without loading everything into context.

The second major principle states that information not needed immediately should not occupy the context window. Tools achieve this through structured note-taking using external files to document decisions, issues, and technical debt. This approach maintains critical context that would otherwise be lost when building complex systems. When context resets through compaction features, agents can use these notes to understand what's been done and what remains, rather than relying solely on compaction summaries. This is particularly valuable for long-horizon tasks which are inherently complex. The creator mentions the standard agent.md file that agents read before sessions, though some agents like Claude use their own formats (claud.md) to guide how external files are structured.

The concept of attention budget addresses why agents randomly pause during long-running tasks - typically when context exceeds 70% of its limit. When the context window goes over 70%, the model must focus harder and hallucination chances increase significantly. For AI agents specifically, this degrades tool usage effectiveness and they often simply ignore available tools. The creator provides several solutions: use compaction proactively before reaching 90% rather than waiting for auto-compact, utilize Claude's built-in rewind feature to delete unnecessary parts during experimentation, and start new context windows for new tasks to prevent previous context from slowing the model. Active monitoring and management of context window usage is essential for maintaining agent performance.

Sub-agents extend the progressive disclosure principle by running tasks in the background within their own isolated context windows, reporting only output back to the main agent. This is particularly valuable for isolated tasks because the main context window remains protected from being bloated with the sub-agent's tool calls and searches. The information stays in dedicated working zones, ensuring efficiency. Since these agents run in the background, users can continue interacting with the main agent on tasks requiring active attention. The creator shares a practical use case: whenever researching new frameworks or rules, they use sub-agents so tool calls and searches remain isolated while only answers return to the main agent.

Understanding which file format to use for different tasks impacts token count and workflow efficiency significantly. YAML is the most token-efficient format, making it ideal for database schemas, security configs, and API details, with indentation helping models structure information properly. Markdown works better for documentation like claud.md because heading levels enable easy navigation between sections. XML is specifically optimized for Claude models - Anthropic states their models are fine-tuned to recognize XML tags as containers and separators, useful for distinct sections like constraints, summaries, or visual details. Other models generally prefer Markdown and YAML over XML. JSON is the least token-efficient due to extra braces and quotes, so the creator only uses it for small items like task states and doesn't recommend it otherwise.

Git serves multiple purposes in context workflows beyond basic version control. A growing trend uses git commit history as a reminder to models of progress made across entire projects or individual tasks. Even without using it for progress tracking, context engineering workflows should operate in git-initialized repositories. The creator explains that context engineering workflows prevent models from doing everything at once, instead acting on planned steps sequentially. When problems occur at any stage, git provides control over which version to revert to and helps evaluate which changes cause issues. Advanced implementations use git worktrees for parallelism, with sub-agents working in dedicated worktrees for parallel work, as demonstrated in various workflows the creator has shown.

Custom commands solve the problem of repeating instructions for common procedures like git commits or documentation updates. Most AI tools provide ways to reuse frequently used prompts. The creator uses custom commands in projects to give Claude reusable guides, such as a catchup command containing instructions on memory structure outside the context window so Claude knows how to catch up with projects without reading every file. Custom commands also enforce structure - the creator uses a commit command that follows specific formats for commit messages and defines pre-commit checks before committing. This standardization means commands keep everything consistent without needing to repeatedly instruct Claude on preferred task execution methods.

MCPs (Model Context Protocol) should be reserved specifically for accessing external data sources. The creator provides concrete examples: Jira MCP enables accessing team management tickets directly so the AI can start implementing changes based on ticket information, while Figma MCP provides Claude Code with app style guides for constructing designs. MCPs are essential for tasks where the model's built-in capabilities fall short and external source interaction is required. Importantly, MCPs can be included directly in custom commands to integrate them into complete workflows. This strategic use of MCPs - only for external data rather than everything - prevents unnecessary context pollution while enabling powerful integrations with external tools and platforms that enhance the AI's capabilities where needed.