The 5 Techniques Separating Top Agentic Engineers Right Now

Key Concepts

• PRD First Development: Utilizing a Product Requirements Document as the central source of truth for project scope.
• Modular Rules Architecture: Breaking down global rules into task-specific modules for efficient context management.
• Commandification: Converting repetitive prompts into reusable commands/workflows.
• Context Reset: Clearing the conversation window between planning and execution, relying on a structured plan document for context.
• System Evolution: Treating bugs as opportunities to improve the AI coding agent’s system (rules, context, commands).
• Agentic Engineering: A systematic approach to working with AI coding assistants.
• LLM (Large Language Model): The underlying technology powering the coding agents (e.g., Claude).
• Context Window: The limited amount of text an LLM can process at once.

PRD First Development

The foundation of effective AI coding lies in defining a clear scope of work using a Product Requirements Document (PRD). This document, formatted in Markdown, serves as the “north star” for the coding agent, outlining everything that needs to be built. For new (“greenfield”) projects, the PRD details the entire MVP or proof of concept. For existing codebases (“brownfield”), it documents the current state and planned additions. The PRD is then broken down into granular features – implementing APIs, UIs, authentication – to prevent the agent from being overwhelmed. Key sections of a PRD include target users, mission statement, in-scope/out-of-scope features, and a high-level architecture.

Modular Rules Architecture & Context Management

Overloading an LLM with excessive rules negatively impacts performance. A modular rules architecture addresses this by separating global rules (commands, testing strategy, logging) from task-specific rules. The core .md file (e.g., claw.md for Claude) remains concise, referencing other Markdown documents containing detailed rules for frontend development, API building, or deployments. This approach ensures relevant context is loaded only when needed, protecting the LLM’s context window. The speaker’s example uses a reference folder within the project to store these task-specific rules, with the global rules file referencing them. A lightweight global rules file (under 200 lines in the example) focuses on project-wide conventions.

Commandification: Reusable Workflows

Repetitive prompts should be transformed into reusable commands. These commands, also Markdown documents, define specific processes for the coding agent. This saves significant keystrokes and promotes consistency. Examples include commands for making Git commits, code reviews, creating PRDs, and executing feature development cycles. The speaker provides a GitHub repository with a collection of their daily-use commands, encouraging users to customize them.

Context Reset for Optimal Execution

A crucial step in the workflow is a “context reset” between the planning and execution phases. After defining the plan (typically outputted as a structured Markdown document), the conversation window with the coding agent is cleared. Execution then begins by simply feeding the agent the structured plan document, minimizing unnecessary context and maximizing reasoning capacity. This is achieved using commands like /cle to wipe the context or restarting the agent.

System Evolution: Learning from Bugs

The most powerful technique involves treating every bug as an opportunity to improve the AI coding agent’s system. Instead of simply fixing the code, the speaker advocates for analyzing why the bug occurred and updating the system – global rules, reference context, or commands – to prevent recurrence. Examples include:

• Incorrect Import Style: Add a rule specifying the correct style.
• Forgotten Tests: Update the structured plan template to include a testing section.
• Authentication Issues: Create a dedicated reference document explaining the authentication flow and update the global rules to reference it during authentication-related tasks.

The process involves prompting the agent to analyze the discrepancy between the plan, execution, and existing rules, identifying areas for improvement. This iterative process transforms the coding agent into a more reliable and powerful tool over time. The speaker emphasizes a mindset shift: “Don’t just fix the bug, fix the system that allowed the bug.”

Examples & Case Studies

The entire discussion is grounded in a practical example: a habit tracker application. The speaker demonstrates the workflow using this application, showcasing:

• A sample PRD document.
• Examples of modular rules files (global claw.md and task-specific files in the reference folder).
• Commands for creating the PRD, priming the agent, and executing the plan.
• The context reset process.

Technical Terms

• PRD (Product Requirements Document): A document outlining the scope, features, and requirements of a project.
• LLM (Large Language Model): The AI model powering coding assistants like Claude.
• Context Window: The limited amount of text an LLM can process at once.
• Agentic Engineering: A systematic approach to working with AI coding assistants.
• Markdown: A lightweight markup language used for formatting documents.
• Hallucination: A term used when an LLM generates incorrect or nonsensical information.

Logical Connections

The video builds a logical progression: starting with defining project scope (PRD), then managing context efficiently (modular rules, context reset), automating tasks (commandification), and finally, continuously improving the system (system evolution). Each technique builds upon the previous one, creating a comprehensive workflow for AI-assisted coding. Context management is a recurring theme, highlighting its critical importance.

Data & Statistics

While no specific statistics are presented, the speaker emphasizes the time-saving benefits of commandification ("save you thousands of keystrokes"). The example of a task-specific rules document being "almost a thousand lines long" illustrates the potential for detailed context when needed.

Notable Quotes

• “PRD is short for product requirement document and that can mean a lot of different things but in this context it is a markdown document a single place to define the entire scope of work for your project.”
• “Don’t just fix the bug, fix the system that allowed the bug.”
• “The goal is to protect the context window of your coding agent.”

Synthesis/Conclusion

The video presents a powerful framework for maximizing the potential of AI coding assistants. By adopting a PRD-first approach, implementing a modular rules architecture, automating tasks with commands, resetting context between phases, and embracing system evolution, developers can move beyond basic prompting and unlock a truly efficient and reliable AI-assisted coding workflow. The key takeaway is that success with AI coding isn’t just about the tools, but about a systematic and thoughtful approach to how those tools are used. The provided GitHub repository offers a practical starting point for implementing these techniques.