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

Key Concepts

• Simple, Iterative Framework: A pragmatic approach to utilizing coding agents, prioritizing a streamlined workflow over complex multi-agent systems.
• AI Layer Evolution: Continuously refining the “AI layer” (PRD, rules, commands, context) through iterative “PIV loops” to improve agent performance and consistency.
• Context Management: Maintaining and strategically providing context to the coding agent is crucial for successful outcomes.
• Greenfield vs. Brownfield Development: The framework is initially focused on new projects (greenfield), with future exploration of integrating into existing projects (brownfield).
• Minimizing Assumptions: Reducing ambiguity in planning documents (PRDs) to prevent cascading errors in code.

Building a Coding Agent Framework for Greenfield Projects (Part 1)

The video demonstrates a framework for leveraging coding agents in greenfield development, emphasizing simplicity and iterative improvement. The presenter contrasts this approach with more complex systems like BMAD or GitHub spec kit, advocating for a customizable and easily manageable workflow. The core philosophy is to minimize time spent on framework creation and maximize coding time. This is achieved through establishing a foundational “AI layer” and utilizing “Plan, Implement, Validate” (PIV) loops. Four golden rules underpin the framework: context management, commandification, a system evolution mindset, and reducing assumptions.

The demonstration centers around building a Linkree clone – a self-hosted landing page with analytics – as a practical example. The initial phase involves creating a Product Requirements Document (PRD), starting with unstructured conversation with the agent and evolving into a structured document containing 233 lines of code. This PRD defines the Minimum Viable Product (MVP) scope. The AI layer consists of assets like the PRD, global rules, and reusable commands (and skills – commands invoked by the user, skills read by the agent). Development is broken down into manageable phases, each following the PIV loop process: Plan (detailed task lists and validation strategies), Implement (delegating coding tasks to the agent), and Validate (testing, including automated regression testing with QA Tech).

Commandification, the creation of reusable commands for common tasks, promotes consistency. Context isolation is employed by clearing the conversation context after planning, relying solely on the structured plan for implementation. Utilizing Git commit history provides a form of long-term memory for the agent. The presenter highlights the cascading impact of poor planning, stating that a bad line in a PRD can lead to thousands of lines of bad code. They also emphasize the importance of reducing the number of assumptions the coding agent makes. The application is deployed to Verscell, showcasing a practical deployment workflow. The presenter dictates at a speed of 226 words per minute using speech-to-text tools like AquaVoice/Whisper Flow/Epicenter Whispering.

System Evolution and AI Layer Refinement (Part 2)

This segment focuses on iteratively improving the coding agent’s performance through “system evolution,” specifically addressing stylistic inconsistencies in the front-end code. Instead of directly modifying the codebase, the presenter enhances the AI layer by adding on-demand context. After prompting the agent for meta-reasoning – reasoning about how to improve its own performance – the recommendation was to create a style.md file within a “reference” folder. This file would detail specific styling guidelines, complementing the existing components.md file (focused on layout), particularly concerning Tailwind CSS and Shadcn/ui.

This process is a “piv loop” – identifying issues, prompting the agent for solutions to improve its underlying rules/context, and repeating the cycle. The presenter emphasizes this loop as “the most high lever part of the entire process” for achieving reliable and repeatable results. Small, focused changes to the AI layer are preferred, with manual implementation of these adjustments rather than allowing the agent full autonomy. The ultimate goal is to refine the agent’s understanding of the project’s specific requirements, leading to a more “in tune” coding agent. Once the AI layer is sufficiently evolved, the piv loop is restarted to build out subsequent phases outlined in the PRD and add new features, ultimately reaching an MVP. The presenter plans to cover “brownfield development” – integrating the agent into existing projects – in a future video.

Conclusion

The presented framework offers a pragmatic and iterative approach to utilizing coding agents in greenfield development. By prioritizing simplicity, context management, and continuous AI layer evolution through PIV loops, developers can maximize coding time and achieve consistent, high-quality results. The emphasis on minimizing assumptions and leveraging tools like Git for long-term memory further enhances the framework’s effectiveness. This approach positions coding agents not as replacements for developers, but as powerful collaborators in the software development process.