My COMPLETE Agentic Coding Workflow to Build Anything (No Fluff or Overengineering)

Detailed Summary

Introduction (0:00 - 02:28)

• Most agentic frameworks are overengineered; a simple, evolvable system is better for individual developers.
• The focus is on greenfield development (new projects) rather than brownfield (existing codebases).
• The framework consists of two parts: setting up the AI layer and executing PIV loops, guided by four golden rules: context management, commandification, system evolution, and using git as long-term memory.

Creating the AI Layer (02:28 - 08:38)

• The AI layer includes the PRD, global rules, reusable commands, and sub-agents.
• Planning starts with an unstructured 'brain dump' using speech-to-text to convey ideas quickly.
• A critical step is instructing the agent to ask clarifying questions to eliminate hidden assumptions before a single line of code is written.

Subagents and PRD Creation (08:38 - 15:42)

• Sub-agents are ideal for research because they isolate context; they process thousands of tokens but only return a concise summary to the main agent.
• The PRD (Product Requirements Document) defines the MVP scope, directory structure, and phases of work.
• Each phase in the PRD becomes a granular implementation target for a future PIV loop.

Global Rules and On-Demand Context (15:42 - 20:50)

• Global rules (e.g., claud.md or rules.md) contain universal constraints like tech stack, testing strategies, and naming conventions.
• Use 'progressive disclosure' for context: keep global rules concise and point the agent to 'on-demand' files (e.g., api.md, components.md) only when relevant to the task.
• This prevents context bloating and maintains agent performance.

The Prime Command (20:50 - 23:18)

• The /prime command is used at the start of every new session to catch the agent up to speed.
• It forces the agent to explore the codebase, read documentation, and check the git log to understand the current state and next steps.

The PIV Loop Framework (23:18 - 31:40)

• Plan: Move from 'vibe planning' to a structured document including success criteria, task lists, and a validation strategy.
• Implement: Delegate all coding to the agent. Before starting, perform a 'context reset' to ensure the agent only has the specific plan and necessary files in its window.
• Validate: The agent performs unit/integration tests and browser automation, followed by a human code review and manual testing.
• Pro-tip: Set up environment variables in an .env.example file beforehand so the agent doesn't get stuck during automated testing.

Live Implementation and Validation (31:40 - 34:53)

• Demonstration of building a 'Link-in-bio' app: the agent successfully implements authentication, link management, and drag-and-drop reordering.
• Trust but verify: even with automated success, manual testing is required to ensure the UI/UX meets expectations.

Keeping Your Codebase Reliable (34:53 - 38:40)

• Regression testing is vital to ensure new features don't break old ones.
• Tools like QA Tech can automate the creation of end-to-end test cases by crawling the site and simulating user journeys.
• This 'test harness' maintains stability as the project grows in complexity.

Conclusion: System Evolution (38:40 - 42:22)

• The final golden rule is evolving the AI layer alongside the code.
• If an agent makes a stylistic or logic error, update the global rules or create a new reference document to prevent it from happening again.
• This creates a compounding effect where the agent becomes more 'in tune' with the developer's preferences over time.

Notable Quotes

"One line of a bad plan is maybe a hundred lines of bad code. But one bad line in a PRD, that could be a thousand bad lines of code because you have misalignment." — Coleam

"Context is your most precious resource when working with AI coding assistants." — Coleam

"Whenever we encounter a bug in our codebase, it is important to not just address the bug, but think about what we can fix in our AI layer so it doesn't happen again." — Coleam