**Summary**
In the video, Tom (a YC partner) shares practical advice for getting the most out of AI‑assisted “vibe coding.” He treats the LLM as a new kind of programming language: to obtain good results you must give it detailed context and clear instructions. His workflow includes:
1. **Planning first** – Work with the LLM to write a comprehensive markdown plan, then implement it section‑by‑section, checking each piece with tests before moving on.
2. **Test‑driven start** – Hand‑craft test cases (or high‑level integration tests) to serve as guardrails; let the LLM generate code that satisfies those tests.
3. **Iterative, incremental development** – Build small, modular pieces, commit each working version to Git, and reset to a clean slate if the model goes off track.
4. **Version control** – Use Git religiously; trust a clean commit over the built‑in undo features of coding agents.
5. **Bug fixing** – Paste error messages directly into the LLM; if it loops, reset, try a different model, add logging, and give very specific fix instructions on a clean codebase.
6. **LLM‑generated instructions** – Create rule files (Cursor, Windsurf, Claude, etc.) that guide the model’s behavior; many founders find hundreds of lines of such rules dramatically improve effectiveness.
7. **Documentation & context** – Download relevant API docs locally and tell the LLM to read them before implementing features.
8. **Multi‑modal input** – Use voice‑to‑text tools (e.g., Aqua) to feed instructions faster than typing; the models tolerate minor transcription errors.
9. **Non‑coding uses** – Leverage LLMs for DevOps tasks (DNS config, Heroku setup), graphic generation (favicons), and as a teaching aid to walk through code line‑by‑line.
10. **Experimentation & model selection** – Continuously try new models (Gemini for planning, Claude Sonnet 3.7 for implementation, etc.) and adapt as capabilities evolve.
11. **Architecture mindset** – Favor modular, service‑based designs with clear API boundaries so the LLM can work within well‑defined limits without causing unintended side‑effects.
Overall, the core message is to treat AI coding assistants as collaborative partners that need precise guidance, thorough testing, disciplined version control, and frequent experimentation—just like any professional software engineering process—while exploiting their strength in handling language‑level tasks, documentation lookup, and repetitive chores.
1. Vibe coding involves programming using natural language instead of traditional code.
2. If an AI IDE gets stuck in a loop, pasting code into an LLM's web UI can provide a solution.
3. Using multiple AI tools like Cursor and Windsurf simultaneously allows for different implementation iterations.
4. Providing detailed context and information is necessary for high-quality results.
5. Starting with handcrafted test cases creates guardrails for code generation.
6. Building a project scope and architecture in a pure LLM before using a coding tool prevents disorganized code.
7. Users should monitor if an LLM is falling into "rabbit holes" or repeating errors.
8. Beginners can use visual tools like Replit or Lovable.
9. Experienced coders can use tools like Windsurf, Cursor, or Claude Code.
10. Creating a comprehensive plan in a markdown file helps guide the implementation process.
11. Implementing projects section by section and committing to Git prevents large-scale errors.
12. Using version control (Git) allows users to revert to a working state if the AI fails.
13. Resetting the codebase and starting fresh is more effective than repeatedly prompting for a fix to the same error.
14. High-level integration tests help catch unnecessary logic changes made by the LLM.
15. LLMs can be used for non-coding tasks like DevOps, DNS configuration, and design.
16. Pasting error messages directly into an LLM is an effective debugging method.
17. Writing specific instructions in configuration files (like `.cursorrules`) increases effectiveness.
18. Downloading API documentation into a local subdirectory helps the LLM access accurate information.
19. Complex features are best implemented first in a standalone, clean codebase.
20. Modular, service-based architectures with clear API boundaries are easier for LLMs to manage than large monorepos.
21. Frameworks with established conventions, such as Ruby on Rails, provide more consistent training data for LLMs.
22. Screenshots can be used to demonstrate UI bugs or provide design inspiration.
23. Voice-to-text tools can accelerate the input of instructions.
24. Frequent refactoring helps maintain small, modular files.
25. Different LLM models excel at different tasks, such as indexing, planning, or implementation.