The Secret To Getting AI To Code Like Experts

Key Concepts

• Project Rules: Custom instructions for AI models within an IDE to guide code generation and adherence to specific development standards.
• Context Window: The amount of information an AI model can consider at any given time, influenced by the code files and project structure.
• Tech Stack: The specific set of technologies (languages, frameworks, libraries) used in a project.
• IDE (Integrated Development Environment): Software applications that provide comprehensive facilities to computer programmers for software development (e.g., Cursor, VS Code).
• Agent Mode: A feature within Cursor that allows interaction with the AI for tasks like generating code or asking questions.
• User Rules vs. Project Rules: User rules are general instructions, while project rules are specific to a particular codebase or project.
• Community-Based Rules: Pre-written rules shared by a community that can be leveraged and adapted.
• Rule Modification: The process of tailoring pre-existing rules to fit a specific project's tech stack and requirements.
• Folder Structure for Rules: Specific directory organization (cursor/rules) required for the IDE to recognize and apply custom rules.
• Always Apply vs. Apply Manually: Settings for project rules to determine if they are automatically applied to all chats or require manual activation.

Upgrading Cursor AI with Project Rules

This video demonstrates how to significantly improve the code output quality of AI assistants like Cursor by implementing "Project Rules." The core idea is to provide the AI with specific, context-aware instructions that mimic the guidance of a senior-level engineer, moving beyond generic code generation.

The Problem: Shooting in the Blank

Without proper configuration, AI models in IDEs start each new chat with a limited context, primarily relying on the existing code in the repository. This often leads to generic or suboptimal code suggestions. The presenter emphasizes that this is akin to "shooting in the blank" if no specific guidance is provided.

The Solution: Project Rules

The key to enhancing AI code generation lies in utilizing "Project Rules." These are custom instructions that can be configured within the IDE's settings. While the presenter mentions "User Rules" for general guidance, the focus of this video is on "Project Rules" due to their critical importance for project-specific AI performance.

Finding and Leveraging Pre-set Rules

The presenter highlights a free community resource (the third link in the description) where users can find pre-set rules. These rules are designed to encapsulate fundamental principles that experienced developers follow.

• Example: A "front-end developer" rule is presented as an example. While not perfect, it's significantly better than having no rule at all.
• Community Contribution: The presenter credits "Jeff" from the community for bringing this resource to his attention.

Adapting Rules to Your Specific Tech Stack

A crucial aspect of effective AI code generation is tailoring the rules to the project's unique tech stack. The presenter explains that what constitutes "senior-level" advice varies greatly depending on the technologies used (e.g., building a video game versus a React/TypeScript application like Thumbio).

Step-by-step process for adapting rules:

1. Identify Your Tech Stack:

   • Use the IDE's "Agent Mode" to ask the AI, "What is my tech stack?"
   • If unsure, screenshot the AI's response and ask it to explain or suggest relevant search terms for your tech stack.
   • The AI might suggest terms like "React and Tailwind front-end engineering."

2. Locate Relevant Rules:

   • Navigate through the community-provided rules directory.
   • Use search functionality within the directory (e.g., searching for "React," "Next.js").
   • The presenter shows examples of narrowing down to specific technologies like "React 19 TypeScript" or "Next.js TypeScript Tailwind CSS."

3. Select and Copy a Suitable Rule:

   • Once a rule that closely matches your project's needs is found, click into it.
   • The presenter notes that community-vetted rules are generally reliable.
   • Copy the content of the chosen rule.

4. Modify the Rule for Specificity:

   • The copied rule needs to be customized to remove irrelevant parts and add specific details about your project.
   • Analogy: The presenter uses the analogy of a "pizza pie" where you remove unwanted toppings (anchovies) and add preferred ones (pineapple) to make it perfect for your taste.
   • Example of Modification: Removing "Next.js JS" if you use Vite, or replacing "shadcn/ui" with "lucid react" if that's your library.

Implementing Project Rules in Cursor

The process of adding a custom rule to Cursor involves specific steps and a particular folder structure.

Step-by-step implementation:

1. Create Necessary Folders:

   • If the cursor/rules directory doesn't exist, create it. This can be done by asking the AI in "Agent Mode": "I need a folder called cursor and I need a folder within cursor called rules."

2. Add a New Rule File:

   • Go to "Add Rule" within the IDE.
   • You can initially name it something temporary like "test."
   • This will create a file (e.g., test.mdc) within the rules folder.

3. Paste and Format the Modified Rule:

   • Paste your customized rule content into the test.mdc file.
   • The presenter notes that the formatting needs to be precise for the IDE to recognize it. If the file isn't structured correctly, the AI might indicate an issue.

4. Troubleshooting Rule Recognition:

   • If the IDE doesn't read your rule, take a screenshot of the error message and paste it into the chat in "Agent Mode," asking for assistance in fixing the structure.

5. Configuring Rule Application:

   • Within the IDE's settings, you can control how rules are applied:
     • Always Apply: The rule is automatically used for every chat session.
     • Apply Manually: The rule needs to be explicitly enabled for a specific chat.
   • Strategic Application: The presenter suggests creating separate rules for front-end and back-end development and configuring them to "Always Apply" to their respective domains or "Apply Manually" when needed. This prevents unnecessary context loading and ensures the right rules are active for the task at hand. For instance, a back-end rule might be set to "Always Apply" when working on back-end files, while a front-end rule could be set to "Apply Manually" for more targeted use.

Key Arguments and Perspectives

• The Power of Context: The central argument is that AI models are only as good as the context they are given. Project rules provide this essential, project-specific context.
• Democratizing Senior-Level Engineering: By implementing these rules, developers can leverage AI to produce code that approaches the quality of a senior engineer, making advanced coding practices more accessible.
• Community Collaboration: The reliance on community-contributed rules highlights the power of collaborative development in improving AI tools.
• Iterative Improvement: The process of finding, adapting, and implementing rules is presented as an iterative one, leading to progressively better AI outputs.

Notable Quotes

• "Every single time we start a new chat here, we are going to be shooting in the blank if you don't add what I'm about to show you."
• "Oh, they're important. Very important." (Referring to Project Rules)
• "What this is doing is that this is making it so that when we use our IDE or app builder, we are making sure that the model will follow by very fundamental rules that every developer should use if they're more experienced."
• "Every single app is different. And because they're different, that means whatever your end value points, whatever you're trying to sell, whatever your tech stack is, the way you approach being a quote unquote senior engineer in that context is going to be different than the person that's building with an entirely different tech stack."
• "Y'all really thought I was playing when I said anyone can code now? That's how simple it is."

Technical Terms and Concepts Explained

• IDE (Integrated Development Environment): Software that provides tools for coding, debugging, and building software. Cursor is an example.
• Context Window: The amount of information an AI can process at once. Larger context windows generally lead to better understanding and more relevant outputs.
• Tech Stack: The combination of programming languages, frameworks, and tools used in a software project.
• Agent Mode: A feature in Cursor that allows users to interact with the AI for various tasks, including asking questions and generating code.
• Rules (User/Project): Instructions given to the AI to guide its behavior and output. Project rules are specific to a particular codebase.
• Repository: A storage location for code files, typically managed by version control systems like Git.
• Markdown (.mdc): A lightweight markup language often used for documentation and configuration files, which the AI can process.

Logical Connections Between Sections

The video progresses logically from identifying a problem (generic AI output) to presenting a solution (Project Rules). It then details how to find these rules, adapt them to specific project needs, and implement them within the IDE. The explanation of folder structure and rule application settings provides practical, actionable steps for users. The emphasis on tailoring rules to the tech stack connects the abstract concept of "senior-level" advice to concrete technical implementation.

Data, Research Findings, or Statistics

No specific data, research findings, or statistics were mentioned in the transcript. The focus was on practical application and methodology.

Conclusion/Synthesis

The core takeaway is that by proactively defining and implementing "Project Rules" within an IDE like Cursor, developers can significantly elevate the quality and relevance of AI-generated code. This involves identifying the project's tech stack, leveraging community-provided rules, customizing them for specificity, and correctly configuring their application within the IDE. This approach transforms the AI from a generic code generator into a more intelligent, context-aware assistant capable of producing outputs akin to those of a senior engineer. The process is presented as accessible, even for those new to such configurations, with the AI itself being a tool to help set up these rules.