My AI Coding Workflow That Actually Works in Production (Template Included!)

Key Concepts

• AI Coding Autonomy Levels: L0 (Manual), L1 (Human-Assisted), L2 (Human-Monitored/Vibe Coding), L3 (Human Out-of-the-Loop/Agentic Coding)
• Architecture Planning: Prioritizing architecture before coding for maintainability and scalability.
• Types as Guardrails: Using type checking to improve AI agent reliability and reduce hallucinations.
• Test-Driven AI Coding: Writing tests before implementing features to provide context and prevent errors.
• Information-Dense Keywords: Using specific keywords (create, update, delete) in prompts for clarity.
• Context Awareness: Understanding what context the AI can and cannot see to avoid hallucinations.
• Model Selection: Choosing the smallest AI model suitable for a given task to optimize efficiency.
• Event-Driven Broker Architecture: A design pattern using events and brokers for asynchronous communication and scalability.
• ADR (Architecture Decision Records): Documenting important architectural decisions for future reference.
• Staging Environment: A replica of the production environment for testing AI agents without risking real data.
• No Broken Windows: Addressing technical debt immediately to prevent further issues.

AI Coding Autonomy Levels

The video introduces four levels of autonomy in AI coding:

• L0 (Fully Manual): Humans perform all coding tasks.
• L1 (Human-Assisted): AI provides code completions (e.g., Copilot) or code snippets are copy-pasted from sources like ChatGPT.
• L2 (Human-Monitored/Vibe Coding): AI handles most tasks, with humans monitoring for errors. Tools include Replit, Cursor, and Vinsurf.
• L3 (Human Out-of-the-Loop/Agentic Coding): AI handles everything from start to finish, with humans only reviewing pull requests. Tools include Cloud Code and Cursor background agents.

The speaker emphasizes that many people fail because they skip L0, L1, and L2 and jump directly to L3, leading to unmanageable codebases.

The Importance of Architecture Planning

The speaker stresses the critical role of architecture planning before writing any code. He recalls David Tondre asking him who he'd hire first if he started his SAS all over again. And he said an architect. A well-defined architecture ensures maintainability and scalability, reducing the need for constant intervention. He structures his projects using four key files:

1. PRD (Product Requirements Document): Defines the product's purpose, features, and target users.
2. Project Structure: Outlines the organization of the codebase.
3. ADR (Architecture Decision Records): Documents important architectural decisions and their rationale.
4. Workflow: Clearly communicates the coding process to the AI.

Types and Tests as Guardrails for AI

The speaker identifies type checking and test-driven development as crucial techniques for reliable AI coding.

• Type Checking: Defining types for requests, responses, components, and database models reduces the AI's ability to hallucinate and make mistakes. Linters catch errors, providing feedback to the AI.
• Test-Driven Development: Writing tests before implementing features ensures that the AI retains context and produces correct code. Tests act as "railroads" that guide the AI towards a reliable solution.

He argues that defining types, tests, and architecture upfront creates a robust framework that minimizes the risk of AI failure.

AI Coding Workflow

The speaker outlines his AI coding workflow:

1. Plan the Architecture: Define the project structure, ADRs, and workflow.
2. Create the Types: Define types for all data structures and APIs.
3. Generate the Tests: Write tests to validate the functionality.
4. Build the Feature: Implement the feature using AI agents, potentially in parallel.
5. Document the Changes: Record key architectural decisions in the ADR document.

Tips for Effective AI Coding

The speaker shares several tips for improving AI coding outcomes:

• Use Information-Dense Keywords: Employ specific keywords like "create," "update," and "delete" in prompts.
• Think About Context: Ensure the AI has sufficient and relevant context to complete the task.
• Use the Smallest Model Possible: Choose the most efficient AI model for the task at hand (e.g., GPT-4 for quick edits, Sonnet for general coding).
• Keep Up with the Ecosystem: Stay informed about new AI coding tools and integrate them into your workflow.

Common Production Pitfalls and How to Avoid Them

The speaker discusses common pitfalls in AI coding and their solutions:

• VIP Coding Disasters (e.g., Replet's database deletion): Avoid connecting AI agents directly to production databases. Use staging environments for testing.
• Accept All Trap (AI recommending non-existent libraries or insecure code): Use modern tech stacks with simplified security rules (e.g., Superbase, Firebase).
• Technical Debt Explosion (AI generating excessive or poorly written code): Enforce a "no broken windows" policy to address technical debt immediately.
• Overcomplicated Frameworks (using frameworks on top of other frameworks): Avoid adding unnecessary layers of abstraction that reduce control over the project.

Cold DM Outreach System: A Practical Example

The speaker demonstrates his AI coding workflow by building a cold DM outreach system that generates personalized videos. The system takes a prospect's name, an ElevenLabs voice ID, and a pre-recorded video as input. It then replaces the generic greeting in the video with the prospect's name, creating a personalized message.

The system uses an event-driven broker architecture with Firebase. The front end allows users to upload videos and specify the greeting's end time. The back end processes the videos in the background using FFmpeg and ElevenLabs.

Building the System Step-by-Step

The speaker guides viewers through the process of building the system:

1. Setting up Firebase: Creating a new Firebase project, enabling Firestore and Firebase Storage, and configuring the web app.
2. Generating the PRD: Using GPT-5 to create a PRD based on user input.
3. Breaking Down the PRD into Tasks: Using GPT-5 to generate a list of tasks based on the PRD, including dependencies and type definitions.
4. Implementing the Tasks: Using Cursor and Cloud Code to implement the tasks in parallel, with multiple agents working on different parts of the codebase.
5. Testing and Debugging: Testing the system with real data and debugging any issues that arise.
6. Deploying the System: Deploying the functions to Firebase and connecting them to the front end.
7. Documenting the Architectural Decisions: Using the AI to document key architectural decisions in the ADR document.

Conclusion

The video provides a comprehensive guide to reliable AI coding, emphasizing the importance of architecture planning, type checking, test-driven development, and careful context management. By following the speaker's workflow and tips, developers can leverage AI to build production-ready systems while maintaining control over the codebase. The cold DM outreach system serves as a practical example of how to apply these principles to create a valuable marketing tool. The key takeaway is that AI coding requires a structured approach and a deep understanding of the underlying technologies to avoid common pitfalls and achieve meaningful productivity gains.